wizapp-stdlib/tests/hashmap/test_hashmap.c

// vim:fileencoding=utf-8:foldmethod=marker

#include "wapp.h"
#include "test_hashmap.h"

wp_persist inline WpU8Stream encoder(void *data);
wp_persist inline b8 key_eq(void *a, void *b);

WpTestFuncResult test_hashmap(void) {
	b8 result     = true;
	WpHashMap map = wpHashMap(WpStr8, i32, encoder, key_eq, 8);
	result        = result && wpHashMapCapacity(&map) == 8 && wpHashMapCount(&map) == 0;
	map           = wpHashMap(WpStr8, i32, encoder, key_eq, 3);
	result        = result && wpHashMapCapacity(&map) == 4 && wpHashMapCount(&map) == 0;
	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_alloc(void) {
	WpAllocator arena = wpMemArenaAllocatorInit(KiB(4));
	b8 result         = true;
	WpHashMap map     = wpHashMapAlloc(WpStr8, i32, &arena, encoder, key_eq, 8);
	result            = result && wpHashMapCapacity(&map) == 8 && wpHashMapCount(&map) == 0;
	map               = wpHashMapAlloc(WpStr8, i32, &arena, encoder, key_eq, 3);
	result            = result && wpHashMapCapacity(&map) == 4 && wpHashMapCount(&map) == 0;

	wpMemArenaAllocatorDestroy(&arena);

	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_get_key_size(void) {
	b8 result     = true;
	WpHashMap map = wpHashMap(WpStr8, i32, encoder, key_eq, 8);
	result        = result && wpHashMapKeySize(&map) == sizeof(WpStr8);
	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_get_value_size(void) {
	b8 result     = true;
	WpHashMap map = wpHashMap(WpStr8, i32, encoder, key_eq, 8);
	result        = result && wpHashMapValueSize(&map) == sizeof(i32);
	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_find(void) {
	b8 result        = true;
	WpHashMap map    = wpHashMap(WpStr8, i32, encoder, key_eq, 8);
	WpStr8Array keys = wpArray(
		WpStr8,
		wpStr8Lit("key1"),
		wpStr8Lit("key2"),
		wpStr8Lit("key3"),
		wpStr8Lit("key4")
	);
	WpI32Array values = wpArray(i32, 1, 2, 3, 4);

	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		wpHashMapInsertCapped(WpStr8, i32, &map, &keys[i], &values[i]);
	}

	WpHashLookupResult res = wpHashMapFind(WpStr8, &map, &keys[3]);

	result = result && res.found && res.ref.dist_and_tag > 0;

	WpStr8 key = wpStr8Lit("key0");
	res        = wpHashMapFind(WpStr8, &map, &key);
	result     = result && !res.found;

	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_update(void) {
	b8 result        = true;
	WpHashMap map    = wpHashMap(WpStr8, i32, encoder, key_eq, 4);
	WpStr8Array keys = wpArray(
		WpStr8,
		wpStr8Lit("key1"),
		wpStr8Lit("key2"),
		wpStr8Lit("key3"),
		wpStr8Lit("key4")
	);
	WpI32Array values = wpArray(i32, 1, 2, 3, 4);

	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		wpHashMapInsertCapped(WpStr8, i32, &map, &keys[i], &values[i]);
	}

	i32 new_value = 0;
	wpHashMapUpdate(WpStr8, i32, &map, &keys[1], &new_value);
	result = result && wpHashMapCapacity(&map) == 4 && wpHashMapCount(&map) == 3 &&
	         wpHashMapValues(i32, &map)[1] == new_value;

	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_insert_capped(void) {
	b8 result        = true;
	WpHashMap map    = wpHashMap(WpStr8, i32, encoder, key_eq, 4);
	WpStr8Array keys = wpArray(
		WpStr8,
		wpStr8Lit("key1"),
		wpStr8Lit("key2"),
		wpStr8Lit("key3"),
		wpStr8Lit("key4")
	);
	WpI32Array values = wpArray(i32, 1, 2, 3, 4);

	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		wpHashMapInsertCapped(WpStr8, i32, &map, &keys[i], &values[i]);
	}

	result = result && wpHashMapCapacity(&map) == 4 && wpHashMapCount(&map) == 3;
	for (u64 i = 0; i < 3; ++i) {
		result = result && wpStr8Equal(wpArrayGet(WpStr8, map.keys, i), &keys[i]);
	}

	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_insert_or_update_capped(void) {
	b8 result        = true;
	WpHashMap map    = wpHashMap(WpStr8, i32, encoder, key_eq, 4);
	WpStr8Array keys = wpArray(
		WpStr8,
		wpStr8Lit("key1"),
		wpStr8Lit("key2"),
		wpStr8Lit("key3"),
		wpStr8Lit("key4")
	);
	WpI32Array values = wpArray(i32, 1, 2, 3, 4);

	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		wpHashMapInsertOrUpdateCapped(WpStr8, i32, &map, &keys[i], &values[i]);
	}

	result = result && wpHashMapCapacity(&map) == 4 && wpHashMapCount(&map) == 3;
	for (u64 i = 0; i < 3; ++i) {
		result = result && wpStr8Equal(&wpHashMapKeys(WpStr8, &map)[i], &keys[i]);
	}

	i32 new_value = 0;
	wpHashMapInsertOrUpdateCapped(WpStr8, i32, &map, &keys[1], &new_value);
	result = result && wpHashMapCapacity(&map) == 4 && wpHashMapCount(&map) == 3 &&
	         wpHashMapValues(i32, &map)[1] == new_value;

	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_insert_alloc(void) {
	WpAllocator arena = wpMemArenaAllocatorInit(KiB(4));
	b8 result         = true;
	WpHashMap map     = wpHashMap(WpStr8, i32, encoder, key_eq, 4);
	WpStr8Array keys  = wpArray(
		WpStr8,
		wpStr8Lit("key1"),
		wpStr8Lit("key2"),
		wpStr8Lit("key3"),
		wpStr8Lit("key4")
	);
	WpI32Array values = wpArray(i32, 1, 2, 3, 4);

	WpStr8Array map_keys = map.keys;

	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		wpHashMapInsertAlloc(WpStr8, i32, &arena, &map, &keys[i], &values[i]);
	}

	result = result && map.keys != map_keys && wpHashMapCapacity(&map) == 8 && wpHashMapCount(&map) == 4;
	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		result = result && wpStr8Equal(&wpHashMapKeys(WpStr8, &map)[i], &keys[i]) &&
		         wpHashMapValues(i32, &map)[i] == values[i];
	}

	wpMemArenaAllocatorDestroy(&arena);

	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_insert_or_update_alloc(void) {
	WpAllocator arena = wpMemArenaAllocatorInit(KiB(4));
	b8 result         = true;
	WpHashMap map     = wpHashMap(WpStr8, i32, encoder, key_eq, 4);
	WpStr8Array keys  = wpArray(
		WpStr8,
		wpStr8Lit("key1"),
		wpStr8Lit("key2"),
		wpStr8Lit("key3"),
		wpStr8Lit("key4")
	);
	WpI32Array values = wpArray(i32, 1, 2, 3, 4);

	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		wpHashMapInsertOrUpdateAlloc(WpStr8, i32, &arena, &map, &keys[i], &values[i]);
	}

	result = result && wpHashMapCapacity(&map) == 8 && wpHashMapCount(&map) == 4;
	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		result = result && wpStr8Equal(&wpHashMapKeys(WpStr8, &map)[i], &keys[i]);
	}

	i32 new_value = 0;
	wpHashMapInsertOrUpdateAlloc(WpStr8, i32, &arena, &map, &keys[1], &new_value);
	result = result && wpHashMapCapacity(&map) == 8 && wpHashMapCount(&map) == 4 &&
	         wpHashMapValues(i32, &map)[1] == new_value;

	wpMemArenaAllocatorDestroy(&arena);

	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_remove(void) {
	b8 result        = true;
	WpHashMap map    = wpHashMap(WpStr8, i32, encoder, key_eq, 4);
	WpStr8Array keys = wpArray(
		WpStr8,
		wpStr8Lit("key1"),
		wpStr8Lit("key2"),
		wpStr8Lit("key3"),
		wpStr8Lit("key4")
	);
	WpI32Array values = wpArray(i32, 1, 2, 3, 4);

	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		wpHashMapInsertCapped(WpStr8, i32, &map, &keys[i], &values[i]);
	}

	wpHashMapRemove(WpStr8, i32, &map, &keys[0]);

	result = result && wpHashMapCapacity(&map) == 4 && wpHashMapCount(&map) == 2;

	return wpTesterResult(result);
}

WpTestFuncResult test_hashmap_clear(void) {
	b8 result        = true;
	WpHashMap map    = wpHashMap(WpStr8, i32, encoder, key_eq, 8);
	WpStr8Array keys = wpArray(
		WpStr8,
		wpStr8Lit("key1"),
		wpStr8Lit("key2"),
		wpStr8Lit("key3"),
		wpStr8Lit("key4")
	);
	WpI32Array values = wpArray(i32, 1, 2, 3, 4);

	for (u64 i = 0; i < wpArrayCount(keys); ++i) {
		wpHashMapInsertCapped(WpStr8, i32, &map, &keys[i], &values[i]);
	}

	wpHashMapClear(WpStr8, i32, &map);

	result = result && wpHashMapCount(&map) == 0;

	return wpTesterResult(result);
}

wp_persist inline WpU8Stream encoder(void *data) {
	WpStr8 *str = (WpStr8 *)data;
	return wpStream(u8, str->buf, str->size);
}

wp_persist inline b8 key_eq(void *a, void *b) {
	WpStr8 *a_str = (WpStr8 *)a;
	WpStr8 *b_str = (WpStr8 *)b;
	return wpStr8Equal(a_str, b_str);
}