From 9f906bfb83613c64abeae7886318a3f71464dd69 Mon Sep 17 00:00:00 2001 From: Jonathan Hoffstadt Date: Fri, 11 Apr 2025 21:58:20 -0500 Subject: [PATCH] test: update pl_ds.h tests --- tests/pl_ds_tests.h | 284 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 246 insertions(+), 38 deletions(-) diff --git a/tests/pl_ds_tests.h b/tests/pl_ds_tests.h index 49e6e3e..41bc53f 100644 --- a/tests/pl_ds_tests.h +++ b/tests/pl_ds_tests.h @@ -9,101 +9,309 @@ void hashmap_test_0(void* pData) { - plHashMap* ptHashMap = NULL; + plHashMap tHashMap = {0}; int* sbiValues = NULL; pl_sb_push(sbiValues, 0); - pl_sb_push(sbiValues, 69); - pl_hm_insert(ptHashMap, pl_hm_hash_str("Dirty Number"), pl_sb_size(sbiValues) - 1); + pl_sb_push(sbiValues, 907); + pl_hm_insert(&tHashMap, pl_hm_hash_str("Dirty Number", 0), pl_sb_size(sbiValues) - 1); pl_sb_push(sbiValues, 117); - pl_hm_insert(ptHashMap, pl_hm_hash_str("Spartan Number"), pl_sb_size(sbiValues) - 1); + pl_hm_insert(&tHashMap, pl_hm_hash_str("Spartan Number", 0), pl_sb_size(sbiValues) - 1); for(uint32_t i = 0; i < 3000; i++) { pl_sb_push(sbiValues, i); - pl_hm_insert(ptHashMap, pl_hm_hash("Spartan Number2", strlen("Spartan Number2"), i), pl_sb_size(sbiValues) - 1); + pl_hm_insert(&tHashMap, pl_hm_hash("Spartan Number2", strlen("Spartan Number2"), i), pl_sb_size(sbiValues) - 1); } - pl_test_expect_int_equal(sbiValues[pl_hm_lookup(ptHashMap, pl_hm_hash_str("Dirty Number"))], 69, NULL); - pl_test_expect_int_equal(sbiValues[pl_hm_lookup(ptHashMap, pl_hm_hash_str("Spartan Number"))], 117, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup(&tHashMap, pl_hm_hash_str("Dirty Number", 0))], 907, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup(&tHashMap, pl_hm_hash_str("Spartan Number", 0))], 117, NULL); - pl_hm_remove(ptHashMap, pl_hm_hash_str("Dirty Number")); + pl_hm_remove(&tHashMap, pl_hm_hash_str("Dirty Number", 0)); - uint64_t ulFreeIndex = pl_hm_get_free_index(ptHashMap); - if(ulFreeIndex == UINT64_MAX) + uint64_t ulFreeIndex = pl_hm_get_free_index(&tHashMap); + if(ulFreeIndex == PL_DS_HASH_INVALID) { pl_sb_add(sbiValues); ulFreeIndex = pl_sb_size(sbiValues) - 1; } - sbiValues[ulFreeIndex] = 666999; - pl_hm_insert(ptHashMap, pl_hm_hash_str("Extra dirty number"), ulFreeIndex); - pl_test_expect_int_equal(sbiValues[pl_hm_lookup(ptHashMap, pl_hm_hash_str("Extra dirty number"))], 666999, NULL); + sbiValues[ulFreeIndex] = 123689; + pl_hm_insert(&tHashMap, pl_hm_hash_str("Extra dirty number", 0), ulFreeIndex); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup(&tHashMap, pl_hm_hash_str("Extra dirty number", 0))], 123689, NULL); - pl_test_expect_int_equal(sbiValues[pl_hm_lookup(ptHashMap, pl_hm_hash_str("Extra dirty number"))], 666999, NULL); - pl_test_expect_int_equal(sbiValues[pl_hm_lookup(ptHashMap, pl_hm_hash_str("Spartan Number"))], 117, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup(&tHashMap, pl_hm_hash_str("Extra dirty number", 0))], 123689, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup(&tHashMap, pl_hm_hash_str("Spartan Number", 0))], 117, NULL); - pl_hm_free(ptHashMap); + pl_hm_free(&tHashMap); pl_sb_free(sbiValues); } void hashmap_test_1(void* pData) { - plHashMap* ptHashMap = NULL; + plHashMap tHashMap = {0}; - pl_hm_insert(ptHashMap, pl_hm_hash_str("Dirty Number"), 69); - pl_hm_insert(ptHashMap, pl_hm_hash_str("Spartan Number"), 117); + pl_hm_insert(&tHashMap, pl_hm_hash_str("Dirty Number", 0), 945); + pl_hm_insert(&tHashMap, pl_hm_hash_str("Spartan Number", 0), 117); - pl_test_expect_int_equal((int)pl_hm_lookup(ptHashMap, pl_hm_hash_str("Dirty Number")), 69, NULL); - pl_test_expect_int_equal((int)pl_hm_lookup(ptHashMap, pl_hm_hash_str("Spartan Number")), 117, NULL); + pl_test_expect_int_equal((int)pl_hm_lookup(&tHashMap, pl_hm_hash_str("Dirty Number", 0)), 945, NULL); + pl_test_expect_int_equal((int)pl_hm_lookup(&tHashMap, pl_hm_hash_str("Spartan Number", 0)), 117, NULL); - pl_hm_free(ptHashMap); + pl_hm_free(&tHashMap); } void hashmap_test_2(void* pData) { - plHashMap* ptHashMap = NULL; + plHashMap tHashMap = {0}; int* sbiValues = NULL; pl_sb_push(sbiValues, 0); - pl_sb_push(sbiValues, 69); - pl_hm_insert_str(ptHashMap, "Dirty Number", pl_sb_size(sbiValues) - 1); + pl_sb_push(sbiValues, 945); + pl_hm_insert_str(&tHashMap, "Dirty Number", pl_sb_size(sbiValues) - 1); pl_sb_push(sbiValues, 117); - pl_hm_insert_str(ptHashMap, "Spartan Number", pl_sb_size(sbiValues) - 1); + pl_hm_insert_str(&tHashMap, "Spartan Number", pl_sb_size(sbiValues) - 1); for(uint32_t i = 0; i < 79; i++) { pl_sb_push(sbiValues, 118); - pl_hm_insert_str(ptHashMap, "Spartan Number2", pl_sb_size(sbiValues) - 1); + pl_hm_insert_str(&tHashMap, "Spartan Number2", pl_sb_size(sbiValues) - 1); } - pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(ptHashMap, "Dirty Number")], 69, NULL); - pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(ptHashMap, "Spartan Number")], 117, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(&tHashMap, "Dirty Number")], 945, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(&tHashMap, "Spartan Number")], 117, NULL); - pl_hm_remove_str(ptHashMap, "Dirty Number"); + pl_hm_remove_str(&tHashMap, "Dirty Number"); - uint64_t ulFreeIndex = pl_hm_get_free_index(ptHashMap); - if(ulFreeIndex == UINT64_MAX) + uint64_t ulFreeIndex = pl_hm_get_free_index(&tHashMap); + if(ulFreeIndex == PL_DS_HASH_INVALID) { pl_sb_add(sbiValues); ulFreeIndex = pl_sb_size(sbiValues) - 1; } - sbiValues[ulFreeIndex] = 666999; - pl_hm_insert_str(ptHashMap, "Extra dirty number", ulFreeIndex); - pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(ptHashMap, "Extra dirty number")], 666999, NULL); + sbiValues[ulFreeIndex] = 945945; + pl_hm_insert_str(&tHashMap, "Extra dirty number", ulFreeIndex); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(&tHashMap, "Extra dirty number")], 945945, NULL); - pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(ptHashMap, "Extra dirty number")], 666999, NULL); - pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(ptHashMap, "Spartan Number")], 117, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(&tHashMap, "Extra dirty number")], 945945, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm_lookup_str(&tHashMap, "Spartan Number")], 117, NULL); - pl_hm_free(ptHashMap); + pl_hm_free(&tHashMap); pl_sb_free(sbiValues); } +void +hashmap_test_3(void* pData) +{ + plHashMap tHashMap = {0}; + + // test empty map + pl_test_expect_uint32_equal(pl_hm_size(&tHashMap), 0, NULL); + + pl_hm_insert(&tHashMap, 417, 117); + pl_test_expect_uint32_equal(pl_hm_size(&tHashMap), 1, NULL); + + // test removal + pl_hm_remove(&tHashMap, 417); + pl_test_expect_uint32_equal(pl_hm_size(&tHashMap), 0, NULL); + + // test collisions + const uint32_t uMask = tHashMap._uBucketCapacity - 1; // assumes bucket count is power of 2 + uint32_t uBucketIndex = 417 & uMask; + uint32_t uBucketIndex0 = (417 + tHashMap._uBucketCapacity) & uMask; + + pl_hm_insert(&tHashMap, 417, 117); + pl_hm_insert(&tHashMap, 417 + tHashMap._uBucketCapacity, 118); + pl_hm_insert(&tHashMap, 417 + tHashMap._uBucketCapacity * 2, 119); + + pl_test_expect_uint64_equal(pl_hm_lookup(&tHashMap, 417), 117, NULL); + pl_test_expect_uint64_equal(pl_hm_lookup(&tHashMap, 417 + tHashMap._uBucketCapacity), 118, NULL); + pl_test_expect_uint64_equal(pl_hm_lookup(&tHashMap, 417 + 2 * tHashMap._uBucketCapacity), 119, NULL); + + pl_hm_remove(&tHashMap, 417 + tHashMap._uBucketCapacity * 2); + pl_test_expect_uint64_equal(pl_hm_lookup(&tHashMap, 417 + 2 * tHashMap._uBucketCapacity), UINT64_MAX, NULL); + pl_hm_remove(&tHashMap, 417); + pl_test_expect_uint64_equal(pl_hm_lookup(&tHashMap, 417), UINT64_MAX, NULL); + pl_hm_remove(&tHashMap, 417 + tHashMap._uBucketCapacity); + pl_test_expect_uint64_equal(pl_hm_lookup(&tHashMap, 417 + tHashMap._uBucketCapacity), UINT64_MAX, NULL); + + pl_test_expect_uint32_equal(pl_hm_size(&tHashMap), 0, NULL); +} + +void +shashmap_test_0(void* pData) +{ + uint64_t auKeys[1024] = {0}; + uint32_t auValues[1024] = {0}; + plHashMapStatic32 tHashMap = { + .auKeys = auKeys, + .auValueBucket = auValues, + .uBucketCount = 1024 + }; + + pl_hms_clear32(&tHashMap); + + int* sbiValues = NULL; + pl_sb_push(sbiValues, 0); + pl_sb_push(sbiValues, 907); + pl_hms_set_str32(&tHashMap, "Dirty Number", pl_sb_size(sbiValues) - 1); + pl_sb_push(sbiValues, 117); + pl_hms_set_str32(&tHashMap, "Spartan Number", pl_sb_size(sbiValues) - 1); + + for(uint32_t i = 0; i < 256; i++) + { + pl_sb_push(sbiValues, i); + pl_hms_set32(&tHashMap, pl_hm_hash("Spartan Number2", strlen("Spartan Number2"), i), pl_sb_size(sbiValues) - 1); + } + + pl_test_expect_int_equal(sbiValues[pl_hms_get_str32(&tHashMap, "Dirty Number")], 907, NULL); + pl_test_expect_int_equal(sbiValues[pl_hms_get_str32(&tHashMap, "Spartan Number")], 117, NULL); +} + +void +hashmap32_test_0(void* pData) +{ + plHashMap32 tHashMap = {0}; + + int* sbiValues = NULL; + pl_sb_push(sbiValues, 0); + pl_sb_push(sbiValues, 907); + pl_hm32_insert(&tHashMap, pl_hm_hash_str("Dirty Number", 0), pl_sb_size(sbiValues) - 1); + pl_sb_push(sbiValues, 117); + pl_hm32_insert(&tHashMap, pl_hm_hash_str("Spartan Number", 0), pl_sb_size(sbiValues) - 1); + + for(uint32_t i = 0; i < 3000; i++) + { + pl_sb_push(sbiValues, i); + pl_hm32_insert(&tHashMap, pl_hm_hash("Spartan Number2", strlen("Spartan Number2"), i), pl_sb_size(sbiValues) - 1); + } + + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup(&tHashMap, pl_hm_hash_str("Dirty Number", 0))], 907, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup(&tHashMap, pl_hm_hash_str("Spartan Number", 0))], 117, NULL); + + pl_hm32_remove(&tHashMap, pl_hm_hash_str("Dirty Number", 0)); + + uint32_t ulFreeIndex = pl_hm32_get_free_index(&tHashMap); + if(ulFreeIndex == PL_DS_HASH32_INVALID) + { + pl_sb_add(sbiValues); + ulFreeIndex = pl_sb_size(sbiValues) - 1; + } + sbiValues[ulFreeIndex] = 123689; + pl_hm32_insert(&tHashMap, pl_hm_hash_str("Extra dirty number", 0), ulFreeIndex); + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup(&tHashMap, pl_hm_hash_str("Extra dirty number", 0))], 123689, NULL); + + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup(&tHashMap, pl_hm_hash_str("Extra dirty number", 0))], 123689, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup(&tHashMap, pl_hm_hash_str("Spartan Number", 0))], 117, NULL); + + pl_hm32_free(&tHashMap); + pl_sb_free(sbiValues); +} + +void +hashmap32_test_1(void* pData) +{ + plHashMap32 tHashMap = {0}; + + pl_hm32_insert(&tHashMap, pl_hm_hash_str("Dirty Number", 0), 945); + pl_hm32_insert(&tHashMap, pl_hm_hash_str("Spartan Number", 0), 117); + + pl_test_expect_int_equal((int)pl_hm32_lookup(&tHashMap, pl_hm_hash_str("Dirty Number", 0)), 945, NULL); + pl_test_expect_int_equal((int)pl_hm32_lookup(&tHashMap, pl_hm_hash_str("Spartan Number", 0)), 117, NULL); + + pl_hm32_free(&tHashMap); +} + +void +hashmap32_test_2(void* pData) +{ + plHashMap32 tHashMap = {0}; + + int* sbiValues = NULL; + pl_sb_push(sbiValues, 0); + pl_sb_push(sbiValues, 945); + pl_hm32_insert_str(&tHashMap, "Dirty Number", pl_sb_size(sbiValues) - 1); + pl_sb_push(sbiValues, 117); + pl_hm32_insert_str(&tHashMap, "Spartan Number", pl_sb_size(sbiValues) - 1); + + for(uint32_t i = 0; i < 79; i++) + { + pl_sb_push(sbiValues, 118); + pl_hm32_insert_str(&tHashMap, "Spartan Number2", pl_sb_size(sbiValues) - 1); + } + + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup_str(&tHashMap, "Dirty Number")], 945, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup_str(&tHashMap, "Spartan Number")], 117, NULL); + + pl_hm32_remove_str(&tHashMap, "Dirty Number"); + + uint32_t ulFreeIndex = pl_hm32_get_free_index(&tHashMap); + if(ulFreeIndex == PL_DS_HASH32_INVALID) + { + pl_sb_add(sbiValues); + ulFreeIndex = pl_sb_size(sbiValues) - 1; + } + sbiValues[ulFreeIndex] = 945945; + pl_hm32_insert_str(&tHashMap, "Extra dirty number", ulFreeIndex); + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup_str(&tHashMap, "Extra dirty number")], 945945, NULL); + + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup_str(&tHashMap, "Extra dirty number")], 945945, NULL); + pl_test_expect_int_equal(sbiValues[pl_hm32_lookup_str(&tHashMap, "Spartan Number")], 117, NULL); + + pl_hm32_free(&tHashMap); + pl_sb_free(sbiValues); +} + +void +hashmap32_test_3(void* pData) +{ + plHashMap32 tHashMap = {0}; + + // test empty map + pl_test_expect_uint32_equal(pl_hm32_size(&tHashMap), 0, NULL); + + pl_hm32_insert(&tHashMap, 417, 117); + pl_test_expect_uint32_equal(pl_hm32_size(&tHashMap), 1, NULL); + + // test removal + pl_hm32_remove(&tHashMap, 417); + pl_test_expect_uint32_equal(pl_hm32_size(&tHashMap), 0, NULL); + + // test collisions + const uint32_t uMask = tHashMap._uBucketCapacity - 1; // assumes bucket count is power of 2 + uint32_t uBucketIndex = 417 & uMask; + uint32_t uBucketIndex0 = (417 + tHashMap._uBucketCapacity) & uMask; + + pl_hm32_insert(&tHashMap, 417, 117); + pl_hm32_insert(&tHashMap, 417 + tHashMap._uBucketCapacity, 118); + pl_hm32_insert(&tHashMap, 417 + tHashMap._uBucketCapacity * 2, 119); + + pl_test_expect_uint64_equal(pl_hm32_lookup(&tHashMap, 417), 117, NULL); + pl_test_expect_uint64_equal(pl_hm32_lookup(&tHashMap, 417 + tHashMap._uBucketCapacity), 118, NULL); + pl_test_expect_uint64_equal(pl_hm32_lookup(&tHashMap, 417 + 2 * tHashMap._uBucketCapacity), 119, NULL); + + pl_hm32_remove(&tHashMap, 417 + tHashMap._uBucketCapacity * 2); + pl_test_expect_uint64_equal(pl_hm32_lookup(&tHashMap, 417 + 2 * tHashMap._uBucketCapacity), UINT32_MAX, NULL); + pl_hm32_remove(&tHashMap, 417); + pl_test_expect_uint64_equal(pl_hm32_lookup(&tHashMap, 417), UINT32_MAX, NULL); + pl_hm32_remove(&tHashMap, 417 + tHashMap._uBucketCapacity); + pl_test_expect_uint64_equal(pl_hm32_lookup(&tHashMap, 417 + tHashMap._uBucketCapacity), UINT32_MAX, NULL); + + pl_test_expect_uint32_equal(pl_hm32_size(&tHashMap), 0, NULL); +} + void pl_ds_tests(void* pData) { pl_test_register_test(hashmap_test_0, NULL); pl_test_register_test(hashmap_test_1, NULL); pl_test_register_test(hashmap_test_2, NULL); + pl_test_register_test(hashmap_test_3, NULL); + + pl_test_register_test(shashmap_test_0, NULL); + + pl_test_register_test(hashmap32_test_0, NULL); + pl_test_register_test(hashmap32_test_1, NULL); + pl_test_register_test(hashmap32_test_2, NULL); + pl_test_register_test(hashmap32_test_3, NULL); } \ No newline at end of file