forked from bartvdbraak/blender
201 lines
5.4 KiB
C++
201 lines
5.4 KiB
C++
/* Apache License, Version 2.0 */
|
|
|
|
#include "testing/testing.h"
|
|
|
|
#define GHASH_INTERNAL_API
|
|
|
|
extern "C" {
|
|
#include "BLI_utildefines.h"
|
|
#include "BLI_ghash.h"
|
|
#include "BLI_rand.h"
|
|
}
|
|
|
|
#define TESTCASE_SIZE 10000
|
|
|
|
/* Only keeping this in case here, for now. */
|
|
#define PRINTF_GHASH_STATS(_gh) \
|
|
{ \
|
|
double q, lf, var, pempty, poverloaded; \
|
|
int bigb; \
|
|
q = BLI_ghash_calc_quality_ex((_gh), &lf, &var, &pempty, &poverloaded, &bigb); \
|
|
printf("GHash stats (%d entries):\n\t" \
|
|
"Quality (the lower the better): %f\n\tVariance (the lower the better): %f\n\tLoad: %f\n\t" \
|
|
"Empty buckets: %.2f%%\n\tOverloaded buckets: %.2f%% (biggest bucket: %d)\n", \
|
|
BLI_ghash_size(_gh), q, var, lf, pempty * 100.0, poverloaded * 100.0, bigb); \
|
|
} void (0)
|
|
|
|
/* Note: for pure-ghash testing, nature of the keys and data have absolutely no importance! So here we just use mere
|
|
* random integers stored in pointers. */
|
|
|
|
static void init_keys(unsigned int keys[TESTCASE_SIZE], const int seed)
|
|
{
|
|
RNG *rng = BLI_rng_new(seed);
|
|
unsigned int *k;
|
|
int i;
|
|
|
|
for (i = 0, k = keys; i < TESTCASE_SIZE; ) {
|
|
/* Risks of collision are low, but they do exist.
|
|
* And we cannot use a GSet, since we test that here! */
|
|
int j, t = BLI_rng_get_uint(rng);
|
|
for (j = i; j--; ) {
|
|
if (keys[j] == t) {
|
|
continue;
|
|
}
|
|
}
|
|
*k = t;
|
|
i++;
|
|
k++;
|
|
}
|
|
BLI_rng_free(rng);
|
|
}
|
|
|
|
/* Here we simply insert and then lookup all keys, ensuring we do get back the expected stored 'data'. */
|
|
TEST(ghash, InsertLookup)
|
|
{
|
|
GHash *ghash = BLI_ghash_new(BLI_ghashutil_inthash_p, BLI_ghashutil_intcmp, __func__);
|
|
unsigned int keys[TESTCASE_SIZE], *k;
|
|
int i;
|
|
|
|
init_keys(keys, 0);
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
BLI_ghash_insert(ghash, SET_UINT_IN_POINTER(*k), SET_UINT_IN_POINTER(*k));
|
|
}
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash), TESTCASE_SIZE);
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
void *v = BLI_ghash_lookup(ghash, SET_UINT_IN_POINTER(*k));
|
|
EXPECT_EQ(GET_UINT_FROM_POINTER(v), *k);
|
|
}
|
|
|
|
BLI_ghash_free(ghash, NULL, NULL);
|
|
}
|
|
|
|
/* Here we simply insert and then remove all keys, ensuring we do get an empty, unshrinked ghash. */
|
|
TEST(ghash, InsertRemove)
|
|
{
|
|
GHash *ghash = BLI_ghash_new(BLI_ghashutil_inthash_p, BLI_ghashutil_intcmp, __func__);
|
|
unsigned int keys[TESTCASE_SIZE], *k;
|
|
int i, bkt_size;
|
|
|
|
init_keys(keys, 10);
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
BLI_ghash_insert(ghash, SET_UINT_IN_POINTER(*k), SET_UINT_IN_POINTER(*k));
|
|
}
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash), TESTCASE_SIZE);
|
|
bkt_size = BLI_ghash_buckets_size(ghash);
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
void *v = BLI_ghash_popkey(ghash, SET_UINT_IN_POINTER(*k), NULL);
|
|
EXPECT_EQ(GET_UINT_FROM_POINTER(v), *k);
|
|
}
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash), 0);
|
|
EXPECT_EQ(BLI_ghash_buckets_size(ghash), bkt_size);
|
|
|
|
BLI_ghash_free(ghash, NULL, NULL);
|
|
}
|
|
|
|
/* Same as above, but this time we allow ghash to shrink. */
|
|
TEST(ghash, InsertRemoveShrink)
|
|
{
|
|
GHash *ghash = BLI_ghash_new(BLI_ghashutil_inthash_p, BLI_ghashutil_intcmp, __func__);
|
|
unsigned int keys[TESTCASE_SIZE], *k;
|
|
int i, bkt_size;
|
|
|
|
BLI_ghash_flag_set(ghash, GHASH_FLAG_ALLOW_SHRINK);
|
|
init_keys(keys, 20);
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
BLI_ghash_insert(ghash, SET_UINT_IN_POINTER(*k), SET_UINT_IN_POINTER(*k));
|
|
}
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash), TESTCASE_SIZE);
|
|
bkt_size = BLI_ghash_buckets_size(ghash);
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
void *v = BLI_ghash_popkey(ghash, SET_UINT_IN_POINTER(*k), NULL);
|
|
EXPECT_EQ(GET_UINT_FROM_POINTER(v), *k);
|
|
}
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash), 0);
|
|
EXPECT_LT(BLI_ghash_buckets_size(ghash), bkt_size);
|
|
|
|
BLI_ghash_free(ghash, NULL, NULL);
|
|
}
|
|
|
|
/* Check copy. */
|
|
TEST(ghash, Copy)
|
|
{
|
|
GHash *ghash = BLI_ghash_new(BLI_ghashutil_inthash_p, BLI_ghashutil_intcmp, __func__);
|
|
GHash *ghash_copy;
|
|
unsigned int keys[TESTCASE_SIZE], *k;
|
|
int i;
|
|
|
|
init_keys(keys, 30);
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
BLI_ghash_insert(ghash, SET_UINT_IN_POINTER(*k), SET_UINT_IN_POINTER(*k));
|
|
}
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash), TESTCASE_SIZE);
|
|
|
|
ghash_copy = BLI_ghash_copy(ghash, NULL, NULL);
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash_copy), TESTCASE_SIZE);
|
|
EXPECT_EQ(BLI_ghash_buckets_size(ghash_copy), BLI_ghash_buckets_size(ghash));
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
void *v = BLI_ghash_lookup(ghash_copy, SET_UINT_IN_POINTER(*k));
|
|
EXPECT_EQ(GET_UINT_FROM_POINTER(v), *k);
|
|
}
|
|
|
|
BLI_ghash_free(ghash, NULL, NULL);
|
|
BLI_ghash_free(ghash_copy, NULL, NULL);
|
|
}
|
|
|
|
/* Check pop. */
|
|
TEST(ghash, Pop)
|
|
{
|
|
GHash *ghash = BLI_ghash_new(BLI_ghashutil_inthash_p, BLI_ghashutil_intcmp, __func__);
|
|
unsigned int keys[TESTCASE_SIZE], *k;
|
|
int i;
|
|
|
|
BLI_ghash_flag_set(ghash, GHASH_FLAG_ALLOW_SHRINK);
|
|
init_keys(keys, 30);
|
|
|
|
for (i = TESTCASE_SIZE, k = keys; i--; k++) {
|
|
BLI_ghash_insert(ghash, SET_UINT_IN_POINTER(*k), SET_UINT_IN_POINTER(*k));
|
|
}
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash), TESTCASE_SIZE);
|
|
|
|
GHashIterState pop_state = {0};
|
|
|
|
for (i = TESTCASE_SIZE / 2; i--; ) {
|
|
void *k, *v;
|
|
bool success = BLI_ghash_pop(ghash, &pop_state, &k, &v);
|
|
EXPECT_EQ(k, v);
|
|
EXPECT_TRUE(success);
|
|
|
|
if (i % 2) {
|
|
BLI_ghash_insert(ghash, SET_UINT_IN_POINTER(i * 4), SET_UINT_IN_POINTER(i * 4));
|
|
}
|
|
}
|
|
|
|
EXPECT_EQ(BLI_ghash_size(ghash), (TESTCASE_SIZE - TESTCASE_SIZE / 2 + TESTCASE_SIZE / 4));
|
|
|
|
{
|
|
void *k, *v;
|
|
while (BLI_ghash_pop(ghash, &pop_state, &k, &v)) {
|
|
EXPECT_EQ(k, v);
|
|
}
|
|
}
|
|
EXPECT_EQ(BLI_ghash_size(ghash), 0);
|
|
|
|
BLI_ghash_free(ghash, NULL, NULL);
|
|
}
|