Mercurial > hg > ucx / file diff

diff: tests/test_hash_map.c

tests/test_hash_map.c

changeset 1605
55b13f583356
parent 1604
68b75c091028
--- a/tests/test_hash_map.c	Sun Dec 14 16:21:09 2025 +0100
+++ b/tests/test_hash_map.c	Sun Dec 14 17:30:17 2025 +0100
@@ -116,7 +116,7 @@
     CxAllocator *allocator = &talloc.base;
     CX_TEST_DO {
         CxMap *map = cxHashMapCreate(allocator, CX_STORE_POINTERS, 4);
-        cxDefineAdvancedDestructor(map, cxFree, allocator);
+        cxSetAdvancedDestructor(map, cxFree, allocator);
 
         char *val1 = cxMalloc(allocator, 8);
         strcpy(val1, "val 1");
@@ -290,7 +290,7 @@
 }
 
 CX_TEST(test_hash_map_integer_keys) {
-    CxMap *map = cxHashMapCreateSimple(sizeof(cxstring));
+    CxMap *map = cxHashMapCreate(NULL, sizeof(cxstring), 0);
     CX_TEST_DO {
         cxstring s1 = cx_str("hello");
         cxstring s2 = cx_str("world");
@@ -537,8 +537,8 @@
 }
 
 CX_TEST(test_hash_map_clone) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
-    CxMap *src = cxHashMapCreateSimple(sizeof(int));
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
     const char *exist_keys[] = {"k1", "k2", "k3"};
     int exists[] = {1, 3, 4};
     const char *source_keys[] = {"k4", "k2", "k5"};
@@ -566,8 +566,8 @@
 }
 
 CX_TEST(test_hash_map_clone_alloc_fail) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
-    CxMap *src = cxHashMapCreateSimple(sizeof(int));
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
     const char *exist_keys[] = {"k1", "k2", "k3"};
     int exists[] = {1, 3, 4};
     const char *source_keys[] = {"k4", "k2", "k5"};
@@ -602,9 +602,9 @@
     CxTestingAllocator talloc;
     cx_testing_allocator_init(&talloc);
     CxAllocator *allocator = &talloc.base;
-    CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    cxDefineAdvancedDestructor(dst, cxFree, allocator);
-    CxMap *src = cxHashMapCreateSimple(CX_STORE_POINTERS);
+    CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    cxSetAdvancedDestructor(dst, cxFree, allocator);
+    CxMap *src = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
     const char *exist_keys[] = {"k1", "k2", "k3"};
     int exists[] = {1, 3, 4};
     const char *source_keys[] = {"k4", "k2", "k5"};
@@ -638,10 +638,10 @@
 }
 
 CX_TEST(test_hash_map_difference) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
 
-    CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS);
+    CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
     const char *s1_keys[] = {"k1", "k2", "k3"};
     int s1_values[] = {1, 3, 4};
     const char *s2_keys[] = {"k4", "k2", "k5"};
@@ -664,10 +664,10 @@
 }
 
 CX_TEST(test_hash_map_difference_alloc_fail) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
 
-    CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS);
+    CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
     const char *s1_keys[] = {"k1", "k2", "k3"};
     int s1_values[] = {1, 3, 4};
     const char *s2_keys[] = {"k4", "k2", "k5"};
@@ -694,9 +694,10 @@
 }
 
 CX_TEST(test_hash_map_list_difference) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
-    CxMap *src = cxHashMapCreateSimple(sizeof(int));
-    CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4);
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
+    cxSetCompareFunc(keys, cx_hash_key_cmp);
 
     const char *src_keys[] = {"k1", "k2", "k3"};
     int src_values[] = {1, 3, 4};
@@ -722,9 +723,10 @@
 }
 
 CX_TEST(test_hash_map_list_difference_alloc_fail) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
-    CxMap *src = cxHashMapCreateSimple(sizeof(int));
-    CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4);
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
+    cxSetCompareFunc(keys, cx_hash_key_cmp);
 
     const char *src_keys[] = {"k1", "k2", "k3"};
     int src_values[] = {1, 3, 4};
@@ -754,11 +756,11 @@
 }
 
 CX_TEST(test_hash_map_difference_non_empty_target) {
-    CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    cxDefineAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
+    CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    cxSetAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
 
-    CxMap *s1 = cxHashMapCreateSimple(sizeof(int));
-    CxMap *s2 = cxHashMapCreateSimple(sizeof(int));
+    CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
     const char *s1_keys[] = {"k1", "k2", "k3"};
     int s1_values[] = {1, 3, 4};
     const char *s2_keys[] = {"k4", "k2", "k5"};
@@ -788,10 +790,11 @@
 }
 
 CX_TEST(test_hash_map_list_difference_non_empty_target) {
-    CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    cxDefineAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
-    CxMap *src = cxHashMapCreateSimple(sizeof(int));
-    CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4);
+    CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    cxSetAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
+    CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
+    cxSetCompareFunc(keys, cx_hash_key_cmp);
 
     const char *src_keys[] = {"k1", "k2", "k3"};
     int src_values[] = {1, 3, 4};
@@ -827,11 +830,11 @@
     CxTestingAllocator talloc;
     cx_testing_allocator_init(&talloc);
     CxAllocator *allocator = &talloc.base;
-    CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    cxDefineAdvancedDestructor(dst, cxFree, allocator);
+    CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    cxSetAdvancedDestructor(dst, cxFree, allocator);
 
-    CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS);
+    CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
     const char *s1_keys[] = {"k1", "k2", "k3"};
     int s1_values[] = {1, 3, 4};
     const char *s2_keys[] = {"k4", "k2", "k5"};
@@ -858,10 +861,10 @@
 }
 
 CX_TEST(test_hash_map_intersection) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
 
-    CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS);
+    CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
     const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
     int s1_values[] = {1, 3, 4, 6};
     const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
@@ -883,10 +886,10 @@
 }
 
 CX_TEST(test_hash_map_intersection_alloc_fail) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
 
-    CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS);
+    CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
     const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
     int s1_values[] = {1, 3, 4, 6};
     const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
@@ -912,9 +915,10 @@
 }
 
 CX_TEST(test_hash_map_list_intersection) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
-    CxMap *src = cxHashMapCreateSimple(sizeof(int));
-    CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4);
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
+    cxSetCompareFunc(keys, cx_hash_key_cmp);
 
     const char *src_keys[] = {"k1", "k2", "k3", "k4"};
     int src_values[] = {1, 3, 4, 6};
@@ -939,9 +943,10 @@
 }
 
 CX_TEST(test_hash_map_list_intersection_alloc_fail) {
-    CxMap *dst = cxHashMapCreateSimple(sizeof(int));
-    CxMap *src = cxHashMapCreateSimple(sizeof(int));
-    CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4);
+    CxMap *dst = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
+    cxSetCompareFunc(keys, cx_hash_key_cmp);
 
     const char *src_keys[] = {"k1", "k2", "k3", "k4"};
     int src_values[] = {1, 3, 4, 6};
@@ -970,11 +975,11 @@
 }
 
 CX_TEST(test_hash_map_intersection_non_empty_target) {
-    CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    cxDefineAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
+    CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    cxSetAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
 
-    CxMap *s1 = cxHashMapCreateSimple(sizeof(int));
-    CxMap *s2 = cxHashMapCreateSimple(sizeof(int));
+    CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
     const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
     int s1_values[] = {1, 3, 4, 6};
     const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
@@ -1003,10 +1008,11 @@
 }
 
 CX_TEST(test_hash_map_list_intersection_non_empty_target) {
-    CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    cxDefineAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
-    CxMap *src = cxHashMapCreateSimple(sizeof(int));
-    CxList *keys = cxArrayListCreate(NULL, cx_hash_key_cmp, sizeof(CxHashKey), 4);
+    CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    cxSetAdvancedDestructor(dst, cxFree, (void*) cxDefaultAllocator);
+    CxMap *src = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxList *keys = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
+    cxSetCompareFunc(keys, cx_hash_key_cmp);
 
     const char *src_keys[] = {"k1", "k2", "k3", "k4"};
     int src_values[] = {1, 3, 4, 6};
@@ -1042,11 +1048,11 @@
     CxTestingAllocator talloc;
     cx_testing_allocator_init(&talloc);
     CxAllocator *allocator = &talloc.base;
-    CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    cxDefineAdvancedDestructor(dst, cxFree, allocator);
+    CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    cxSetAdvancedDestructor(dst, cxFree, allocator);
 
-    CxMap *s1 = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    CxMap *s2 = cxHashMapCreateSimple(CX_STORE_POINTERS);
+    CxMap *s1 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    CxMap *s2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
     const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
     int s1_values[] = {1, 3, 4, 6};
     const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
@@ -1070,8 +1076,8 @@
 }
 
 CX_TEST(test_hash_map_union) {
-    CxMap *s1 = cxHashMapCreateSimple(sizeof(int));
-    CxMap *s2 = cxHashMapCreateSimple(sizeof(int));
+    CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
     const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
     int s1_values[] = {1, 3, 4, 6};
     const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
@@ -1099,11 +1105,11 @@
     CxTestingAllocator talloc;
     cx_testing_allocator_init(&talloc);
     CxAllocator *allocator = &talloc.base;
-    CxMap *dst = cxHashMapCreateSimple(CX_STORE_POINTERS);
-    cxDefineAdvancedDestructor(dst, cxFree, allocator);
+    CxMap *dst = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
+    cxSetAdvancedDestructor(dst, cxFree, allocator);
 
-    CxMap *s1 = cxHashMapCreateSimple(sizeof(int));
-    CxMap *s2 = cxHashMapCreateSimple(sizeof(int));
+    CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
     const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
     int s1_values[] = {1, 3, 4, 6};
     const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
@@ -1132,8 +1138,8 @@
 }
 
 CX_TEST(test_hash_map_union_alloc_fail) {
-    CxMap *s1 = cxHashMapCreateSimple(sizeof(int));
-    CxMap *s2 = cxHashMapCreateSimple(sizeof(int));
+    CxMap *s1 = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *s2 = cxHashMapCreate(NULL, sizeof(int), 0);
     const char *s1_keys[] = {"k1", "k2", "k3", "k4"};
     int s1_values[] = {1, 3, 4, 6};
     const char *s2_keys[] = {"k4", "k5", "k2", "k6"};
@@ -1163,26 +1169,26 @@
 
 CX_TEST(test_hash_map_simple_clones) {
     int v = 47; // the value does not matter in this test
-    CxMap *a = cxHashMapCreateSimple(sizeof(int));
+    CxMap *a = cxHashMapCreate(NULL, sizeof(int), 0);
     cxMapPut(a, "k1", &v);
     cxMapPut(a, "k2", &v);
     cxMapPut(a, "k3", &v);
     cxMapPut(a, "k4", &v);
 
-    CxMap *b = cxHashMapCreateSimple(sizeof(int));
+    CxMap *b = cxHashMapCreate(NULL, sizeof(int), 0);
     cxMapPut(b, "k0", &v);
     cxMapPut(b, "k2", &v);
     cxMapPut(b, "k5", &v);
 
-    CxMap *c = cxHashMapCreateSimple(sizeof(int));
+    CxMap *c = cxHashMapCreate(NULL, sizeof(int), 0);
     cxMapPut(c, "k3", &v);
     cxMapPut(c, "k4", &v);
     cxMapPut(c, "k5", &v);
 
 
     CxHashKey k;
-    CxList *kl1 = cxArrayListCreateSimple(sizeof(CxHashKey), 4);
-    cxCollectionCompareFunc(kl1, cx_hash_key_cmp);
+    CxList *kl1 = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
+    cxSetCompareFunc(kl1, cx_hash_key_cmp);
     k = CX_HASH_KEY("k0");
     cxListAdd(kl1, &k);
     k = CX_HASH_KEY("k2");
@@ -1190,8 +1196,8 @@
     k = CX_HASH_KEY("k5");
     cxListAdd(kl1, &k);
 
-    CxList *kl2 = cxArrayListCreateSimple(sizeof(CxHashKey), 4);
-    cxCollectionCompareFunc(kl2, cx_hash_key_cmp);
+    CxList *kl2 = cxArrayListCreate(NULL, sizeof(CxHashKey), 4);
+    cxSetCompareFunc(kl2, cx_hash_key_cmp);
     k = CX_HASH_KEY("k3");
     cxListAdd(kl2, &k);
     k = CX_HASH_KEY("k4");
@@ -1199,8 +1205,8 @@
     k = CX_HASH_KEY("k5");
     cxListAdd(kl2, &k);
 
-    CxMap *d1 = cxHashMapCreateSimple(sizeof(int));
-    CxMap *d2 = cxHashMapCreateSimple(sizeof(int));
+    CxMap *d1 = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *d2 = cxHashMapCreate(NULL, sizeof(int), 0);
 
     CX_TEST_DO {
         CX_TEST_ASSERT(0 == cxMapCloneShallow(d1, a));
@@ -1264,8 +1270,8 @@
 }
 
 CX_TEST(test_hash_map_compare) {
-    CxMap *map1 = cxHashMapCreateSimple(sizeof(int));
-    CxMap *map2 = cxHashMapCreateSimple(CX_STORE_POINTERS);
+    CxMap *map1 = cxHashMapCreate(NULL, sizeof(int), 0);
+    CxMap *map2 = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
     // TODO: fix specification of compare function once #622 is realized
     map1->collection.cmpfunc = cx_cmp_int;
     map2->collection.cmpfunc = cx_cmp_int;

Mercurial Repository: ucx

mercurial