bool
ck_rhs_rebuild(struct ck_rhs *hs)
{
return ck_rhs_grow(hs, hs->map->capacity);
}
static void
run_test(unsigned int is, unsigned int ad)
{
ck_rhs_t hs[16];
const size_t size = sizeof(hs) / sizeof(*hs);
size_t i, j;
const char *blob = "#blobs";
unsigned long h;
if (ck_rhs_init(&hs[0], CK_RHS_MODE_SPMC | CK_RHS_MODE_OBJECT | ad, hs_hash, hs_compare, &my_allocator, is, 6602834) == false)
ck_error("ck_rhs_init\n");
for (j = 0; j < size; j++) {
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
if (ck_rhs_get(&hs[j], h, test[i]) != NULL) {
continue;
}
if (i & 1) {
if (ck_rhs_put_unique(&hs[j], h, test[i]) == false)
ck_error("ERROR [%zu]: Failed to insert unique (%s)\n", j, test[i]);
} else if (ck_rhs_apply(&hs[j], h, test[i], test_unique, (char *)test[i]) == false) {
ck_error("ERROR: Failed to apply for insertion.\n");
}
if (i & 1) {
if (ck_rhs_remove(&hs[j], h, test[i]) == false)
ck_error("ERROR [%zu]: Failed to remove unique (%s)\n", j, test[i]);
} else if (ck_rhs_apply(&hs[j], h, test[i], test_remove, NULL) == false) {
ck_error("ERROR: Failed to remove apply.\n");
}
if (ck_rhs_apply(&hs[j], h, test[i], test_negative, (char *)test[i]) == false)
ck_error("ERROR: Failed to apply.\n");
break;
}
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
ck_rhs_put(&hs[j], h, test[i]);
if (ck_rhs_put(&hs[j], h, test[i]) == true) {
ck_error("ERROR [%u] [1]: put must fail on collision (%s).\n", is, test[i]);
}
if (ck_rhs_get(&hs[j], h, test[i]) == NULL) {
ck_error("ERROR [%u]: get must not fail after put\n", is);
}
}
/* Test grow semantics. */
ck_rhs_grow(&hs[j], 128);
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
if (ck_rhs_put(&hs[j], h, test[i]) == true) {
ck_error("ERROR [%u] [2]: put must fail on collision.\n", is);
}
if (ck_rhs_get(&hs[j], h, test[i]) == NULL) {
ck_error("ERROR [%u]: get must not fail\n", is);
}
}
h = blob[0];
if (ck_rhs_get(&hs[j], h, blob) == NULL) {
if (j > 0)
ck_error("ERROR [%u]: Blob must always exist after first.\n", is);
if (ck_rhs_put(&hs[j], h, blob) == false) {
ck_error("ERROR [%u]: A unique blob put failed.\n", is);
}
} else {
if (ck_rhs_put(&hs[j], h, blob) == true) {
ck_error("ERROR [%u]: Duplicate blob put succeeded.\n", is);
}
}
/* Grow set and check get semantics. */
ck_rhs_grow(&hs[j], 512);
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
if (ck_rhs_get(&hs[j], h, test[i]) == NULL) {
ck_error("ERROR [%u]: get must not fail\n", is);
}
}
/* Delete and check negative membership. */
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
void *r;
h = test[i][0];
if (ck_rhs_get(&hs[j], h, test[i]) == NULL)
continue;
if (r = ck_rhs_remove(&hs[j], h, test[i]), r == NULL) {
ck_error("ERROR [%u]: remove must not fail\n", is);
}
if (strcmp(r, test[i]) != 0) {
ck_error("ERROR [%u]: Removed incorrect node (%s != %s)\n", (char *)r, test[i], is);
}
}
/* Test replacement semantics. */
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
void *r;
bool d;
h = test[i][0];
d = ck_rhs_get(&hs[j], h, test[i]) != NULL;
if (ck_rhs_set(&hs[j], h, test[i], &r) == false) {
ck_error("ERROR [%u]: Failed to set\n", is);
}
/* Expected replacement. */
if (d == true && (r == NULL || strcmp(r, test[i]) != 0)) {
ck_error("ERROR [%u]: Incorrect previous value: %s != %s\n",
is, test[i], (char *)r);
}
/* Replacement should succeed. */
if (ck_rhs_fas(&hs[j], h, test[i], &r) == false)
ck_error("ERROR [%u]: ck_rhs_fas must succeed.\n", is);
if (strcmp(r, test[i]) != 0) {
ck_error("ERROR [%u]: Incorrect replaced value: %s != %s\n",
is, test[i], (char *)r);
}
if (ck_rhs_fas(&hs[j], h, negative, &r) == true)
ck_error("ERROR [%u]: Replacement of negative should fail.\n", is);
if (ck_rhs_set(&hs[j], h, test[i], &r) == false) {
ck_error("ERROR [%u]: Failed to set [1]\n", is);
}
if (strcmp(r, test[i]) != 0) {
ck_error("ERROR [%u]: Invalid &hs[j]: %s != %s\n", (char *)r, test[i], is);
}
/* Attempt in-place mutation. */
if (ck_rhs_apply(&hs[j], h, test[i], test_ip, (void *)test[i]) == false)
ck_error("ERROR [%u]: Failed to apply: %s != %s\n", is, (char *)r, test[i]);
d = ck_rhs_get(&hs[j], h, test[i]) != NULL;
if (d == false)
ck_error("ERROR [%u]: Expected [%s] to exist.\n", is, test[i]);
}
if (j == size - 1)
break;
if (ck_rhs_move(&hs[j + 1], &hs[j], hs_hash, hs_compare, &my_allocator) == false)
ck_error("Failed to move hash table");
ck_rhs_gc(&hs[j + 1]);
if (ck_rhs_rebuild(&hs[j + 1]) == false)
ck_error("Failed to rebuild");
}
return;
}
