tests/test_kv_list.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2025 Mike Becker, Olaf Wintermann All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "cx/test.h"
#include "util_allocator.h"

#include "cx/kv_list.h"

static int kv_list_test_destr_val;
static void kv_list_test_destr(void *data) {
    kv_list_test_destr_val = *(int*)data;
}

static void *kv_list_test_destr2_extra;
static int kv_list_test_destr2_val;
static void kv_list_test_destr2(void* extra, void *data) {
    kv_list_test_destr2_extra = extra;
    kv_list_test_destr2_val = *(int*)data;
}

CX_TEST(test_kv_list_map_as_list) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);
        CX_TEST_ASSERT(map != NULL);
        CxList *list_from_map = cxKvListAsList(map);
        CX_TEST_ASSERT(list_from_map == list);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_free_as_map) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    CX_TEST_DO {
        CxList *list = cxKvListCreate(&talloc.base, NULL, 1);
        cxListAddArray(list, "test", 4);
        CxMap *map = cxKvListAsMap(list);
        cxMapFree(map);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
}

CX_TEST(test_kv_list_free_as_list) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    CX_TEST_DO {
        CxMap *map = cxKvListCreateAsMap(&talloc.base, NULL, sizeof(int));
        int x = 5;
        cxMapPut(map, "test", &x);
        CxList *list = cxKvListAsList(map);
        cxListFree(list);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
}

CX_TEST(test_kv_list_remove) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        x = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "abc", &x));
        x = 47;
        CX_TEST_ASSERT(0 == cxMapPut(map, "efg", &x));
        x = 90;
        CX_TEST_ASSERT(0 == cxMapPut(map, "hij", &x));

        CX_TEST_ASSERT(cxMapSize(map) == 4);
        CX_TEST_ASSERT(cxListSize(list) == 4);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "efg") == 47);
        CX_TEST_ASSERT(0 == cxListRemove(list, 2));
        CX_TEST_ASSERT(cxListSize(list) == 3);
        CX_TEST_ASSERT(cxMapSize(map) == 3);
        CX_TEST_ASSERT(cxMapGet(map, "efg") == NULL);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);
        CX_TEST_ASSERT(0 == cxListRemove(list, 0));
        CX_TEST_ASSERT(cxListSize(list) == 2);
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "hij") == 90);
        CX_TEST_ASSERT(0 == cxListRemove(list, 1));
        CX_TEST_ASSERT(cxListSize(list) == 1);
        CX_TEST_ASSERT(cxMapSize(map) == 1);
        CX_TEST_ASSERT(cxMapGet(map, "hij") == NULL);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_find_and_remove) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    cxCollectionCompareFunc(list, cx_cmp_int);
    int x, y;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        x = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "abc", &x));
        x = 47;
        CX_TEST_ASSERT(0 == cxMapPut(map, "efg", &x));
        x = 90;
        CX_TEST_ASSERT(0 == cxMapPut(map, "hij", &x));

        CX_TEST_ASSERT(cxMapSize(map) == 4);
        CX_TEST_ASSERT(cxListSize(list) == 4);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "efg") == 47);
        y = 47;
        CX_TEST_ASSERT(2 == cxListFindRemove(list, &y));
        CX_TEST_ASSERT(cxListSize(list) == 3);
        CX_TEST_ASSERT(cxMapSize(map) == 3);
        CX_TEST_ASSERT(cxMapGet(map, "efg") == NULL);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);
        y = 13;
        CX_TEST_ASSERT(0 == cxListFindRemove(list, &y));
        CX_TEST_ASSERT(cxListSize(list) == 2);
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "hij") == 90);
        y = 90;
        CX_TEST_ASSERT(1 == cxListFindRemove(list, &y));
        CX_TEST_ASSERT(cxListSize(list) == 1);
        CX_TEST_ASSERT(cxMapSize(map) == 1);
        CX_TEST_ASSERT(cxMapGet(map, "hij") == NULL);

        y = 666;
        CX_TEST_ASSERT(cxListSize(list) == cxListFindRemove(list, &y));

        y = 37;
        CX_TEST_ASSERT(0 == cxListFindRemove(list, &y));
        CX_TEST_ASSERT(cxListSize(list) == 0);
        CX_TEST_ASSERT(cxMapSize(map) == 0);

        CX_TEST_ASSERT(0 == cxListFindRemove(list, &y));
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_remove_and_get) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x, y;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        x = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "abc", &x));
        x = 47;
        CX_TEST_ASSERT(0 == cxMapPut(map, "efg", &x));
        x = 90;
        CX_TEST_ASSERT(0 == cxMapPut(map, "hij", &x));

        CX_TEST_ASSERT(cxMapSize(map) == 4);
        CX_TEST_ASSERT(cxListSize(list) == 4);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "efg") == 47);
        CX_TEST_ASSERT(0 == cxListRemoveAndGet(list, 2, &y));
        CX_TEST_ASSERT(y == 47);
        CX_TEST_ASSERT(cxListSize(list) == 3);
        CX_TEST_ASSERT(cxMapSize(map) == 3);
        CX_TEST_ASSERT(cxMapGet(map, "efg") == NULL);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);
        CX_TEST_ASSERT(0 == cxListRemoveAndGet(list, 0, &y));
        CX_TEST_ASSERT(y == 13);
        CX_TEST_ASSERT(cxListSize(list) == 2);
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);

        CX_TEST_ASSERT(*(int*)cxMapGet(map, "hij") == 90);
        CX_TEST_ASSERT(0 == cxListRemoveAndGet(list, 1, &y));
        CX_TEST_ASSERT(y == 90);
        CX_TEST_ASSERT(cxListSize(list) == 1);
        CX_TEST_ASSERT(cxMapSize(map) == 1);
        CX_TEST_ASSERT(cxMapGet(map, "hij") == NULL);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_remove_array) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        x = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "abc", &x));
        x = 47;
        CX_TEST_ASSERT(0 == cxMapPut(map, "efg", &x));
        x = 90;
        CX_TEST_ASSERT(0 == cxMapPut(map, "hij", &x));

        CX_TEST_ASSERT(cxMapSize(map) == 4);
        CX_TEST_ASSERT(cxListSize(list) == 4);

        CX_TEST_ASSERT(2 == cxListRemoveArray(list, 1, 2));
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(cxListSize(list) == 2);
        CX_TEST_ASSERT(cxMapGet(map, "abc") == NULL);
        CX_TEST_ASSERT(cxMapGet(map, "efg") == NULL);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "hij") == 90);
        CX_TEST_ASSERT(cxListAt(list, 0) == cxMapGet(map, "xyz"));
        CX_TEST_ASSERT(cxListAt(list, 1) == cxMapGet(map, "hij"));
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_remove_array_and_get) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        x = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "abc", &x));
        x = 47;
        CX_TEST_ASSERT(0 == cxMapPut(map, "efg", &x));
        x = 90;
        CX_TEST_ASSERT(0 == cxMapPut(map, "hij", &x));

        CX_TEST_ASSERT(cxMapSize(map) == 4);
        CX_TEST_ASSERT(cxListSize(list) == 4);

        int y[2];

        CX_TEST_ASSERT(2 == cxListRemoveArrayAndGet(list, 1, 2, y));
        CX_TEST_ASSERT(y[0] == 37);
        CX_TEST_ASSERT(y[1] == 47);
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(cxListSize(list) == 2);
        CX_TEST_ASSERT(cxMapGet(map, "abc") == NULL);
        CX_TEST_ASSERT(cxMapGet(map, "efg") == NULL);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "hij") == 90);
        CX_TEST_ASSERT(cxListAt(list, 0) == cxMapGet(map, "xyz"));
        CX_TEST_ASSERT(cxListAt(list, 1) == cxMapGet(map, "hij"));
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_map_put) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));

        x = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "abc", &x));

        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "abc") == 37);

        CX_TEST_ASSERT(cxListSize(list) == 2);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 13);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 1) == 37);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_map_put_ptr) {
    CxList *list = cxKvListCreateSimple(CX_STORE_POINTERS);
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);
        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        x = 37;
        CX_TEST_ASSERT((int*)cxListAt(list, 0) == &x);
        CX_TEST_ASSERT((int*)cxMapGet(map, "xyz") == &x);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_map_put_not_hashed) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);
        x = 13;
        // test with a custom key that was not hashed, yet
        CxHashKey key = {0};
        key.data = "xyz";
        key.len = 3;
        CX_TEST_ASSERT(0 == cxMapPut(map, key, &x));
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 13);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);

        // remove and check if the copied key is correctly removed
        CX_TEST_ASSERT(0 == cxListRemove(list, 0));
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_map_put_overwrite) {
    CxList *list = cxKvListCreateSimple(CX_STORE_POINTERS);
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    CxAllocator *al = &talloc.base;
    int *x, *y;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);
        cxDefineAdvancedDestructor(map, cxFree, al);
        x = cxMalloc(al, sizeof(int));
        y = cxMalloc(al, sizeof(int));
        *x = 13;
        *y = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", x));
        CX_TEST_ASSERT(cxCollectionSize(map) == 1);
        CX_TEST_ASSERT(cxCollectionSize(list) == 1);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 13);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", y));
        CX_TEST_ASSERT(cxCollectionSize(map) == 1);
        CX_TEST_ASSERT(cxCollectionSize(list) == 1);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 37);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 37);
        cxMapClear(map);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
    cxListFree(list);
}

CX_TEST(test_kv_list_map_remove) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));

        x = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "abc", &x));

        CX_TEST_ASSERT(cxMapSize(map) == 2);

        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(cxMapSize(map) == 1);
        CX_TEST_ASSERT(cxMapGet(map, "abc") != NULL);
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);

        CX_TEST_ASSERT(cxListSize(list) == 1);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 37);

        CX_TEST_ASSERT(0 != cxMapRemove(map, "xyz"));
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_map_remove_and_get) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x, y;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 13;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));

        x = 37;
        CX_TEST_ASSERT(0 == cxMapPut(map, "abc", &x));

        CX_TEST_ASSERT(cxMapSize(map) == 2);
        cxDefineDestructor(map, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        y = 0;
        CX_TEST_ASSERT(0 == cxMapRemoveAndGet(map, "xyz", &y));
        CX_TEST_ASSERT(y == 13);
        // destr not called!
        CX_TEST_ASSERT(kv_list_test_destr_val == 0);
        CX_TEST_ASSERT(cxMapSize(map) == 1);
        CX_TEST_ASSERT(cxMapGet(map, "abc") != NULL);
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);

        CX_TEST_ASSERT(cxListSize(list) == 1);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 37);

        CX_TEST_ASSERT(0 != cxMapRemove(map, "xyz"));
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_set_key) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 47;
        cxListAdd(list, &x);
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 0, "xyz"));
        // index out of bounds:
        CX_TEST_ASSERT(0 != cxKvListSetKey(list, 1, "abc"));

        CxMap *map = cxKvListAsMap(list);

        CX_TEST_ASSERT(cxMapSize(map) == 1);

        int *y = cxMapGet(map, "xyz");
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 47);

        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);

        CX_TEST_ASSERT(cxListSize(list) == 0);

        // now check with a non-prehashed key
        x = 85;
        cxListAdd(list, &x);
        CxHashKey key = {0};
        key.data = "abc";
        key.len = 3;
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 0, key));
        y = cxMapGet(map, "abc");
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 85);

        CX_TEST_ASSERT(0 == cxMapRemove(map, "abc"));
        CX_TEST_ASSERT(cxMapGet(map, "abc") == NULL);

        CX_TEST_ASSERT(cxListSize(list) == 0);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_set_key_already_exists) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 47;
        cxListAdd(list, &x);
        x = 11;
        cxListAdd(list, &x);
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 1, "xyz"));
        // already exists
        CX_TEST_ASSERT(0 != cxKvListSetKey(list, 0, "xyz"));

        CxMap *map = cxKvListAsMap(list);

        CX_TEST_ASSERT(cxMapSize(map) == 1);

        int *y = cxMapGet(map, "xyz");
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 11);

        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);
        CX_TEST_ASSERT(cxListSize(list) == 1);

        // now we can assign the key again
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 0, "xyz"));
        y = cxMapGet(map, "xyz");
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 47);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_set_key_again) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 47;
        cxListAdd(list, &x);
        x = 11;
        cxListAdd(list, &x);
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 1, "xyz"));
        // calling it twice is also okay!
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 1, "xyz"));

        CxMap *map = cxKvListAsMap(list);

        CX_TEST_ASSERT(cxMapSize(map) == 1);

        int *y = cxMapGet(map, "xyz");
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 11);

        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(cxMapGet(map, "xyz") == NULL);
        CX_TEST_ASSERT(cxListSize(list) == 1);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_remove_key) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 47;
        cxMapPut(map, "xyz", &x);
        x = 11;
        cxMapPut(map, "abc", &x);
        x = 1337;
        cxMapPut(map, "efg", &x);
        CX_TEST_ASSERT(cxMapSize(map) == 3);

        int *y = cxMapGet(map, "abc");
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 11);

        CX_TEST_ASSERT(0 == cxKvListRemoveKey(list, 1));
        CX_TEST_ASSERT(cxMapGet(map, "abc") == NULL);
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(cxListSize(list) == 3);

        CX_TEST_ASSERT(*(int*)cxListAt(list, 1) == 11);

        y = cxMapGet(map, "xyz");
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 47);

        y = cxMapGet(map, "efg");
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 1337);

        // idempotence
        CX_TEST_ASSERT(0 == cxKvListRemoveKey(list, 1));

        // index out of bounds:
        CX_TEST_ASSERT(0 != cxKvListRemoveKey(list, 3));
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_get_key) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        CxMap *map = cxKvListAsMap(list);

        x = 47;
        cxMapPut(map, "xyz", &x);
        x = 11;
        cxMapPut(map, "abc", &x);
        x = 1337;
        cxMapPut(map, "efg", &x);
        CX_TEST_ASSERT(cxMapSize(map) == 3);

        const CxHashKey *key = cxKvListGetKey(list, 1);
        int *y = cxMapGet(map, *key);
        CX_TEST_ASSERT(y != NULL);
        CX_TEST_ASSERT(*y == 11);

        // removing the element
        CX_TEST_ASSERT(0 == cxMapRemove(map, cx_strn(key->data, key->len)));
        key = cxKvListGetKey(list, 1);
        CX_TEST_ASSERT(0 == cx_strcmp(CX_STR("efg"), cx_strn(key->data, key->len)));

        // remove the key of element
        CX_TEST_ASSERT(0 == cxKvListRemoveKey(list, 1));
        CX_TEST_ASSERT(NULL == cxKvListGetKey(list, 1));

        // index out of bounds:
        CX_TEST_ASSERT(NULL == cxKvListGetKey(list, 3));
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_insert_with_key) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 47;
        cxKvListAdd(list, "xyz", &x);
        x = 11;
        cxKvListAdd(list, "abc", &x);
        x = 1337;
        cxKvListInsert(list, 1, "efg", &x);

        CX_TEST_ASSERT(cxListSize(list) == 3);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 47);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 1) == 1337);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 2) == 11);

        CxMap *map = cxKvListAsMap(list);
        CX_TEST_ASSERT(cxMapSize(map) == 3);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 47);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "abc") == 11);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "efg") == 1337);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_insert_ptr_with_key) {
    CxList *list = cxKvListCreateSimple(CX_STORE_POINTERS);
    int x, y, z;
    CX_TEST_DO {
        x = 15;
        cxKvListAdd(list, "xyz", &x);
        y = 16;
        cxKvListAdd(list, "abc", &y);
        z = 17;
        cxKvListInsert(list, 1, "efg", &z);
        x = 47;
        y = 11;
        z = 1337;

        CX_TEST_ASSERT(cxListSize(list) == 3);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 47);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 1) == 1337);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 2) == 11);

        CxMap *map = cxKvListAsMap(list);
        CX_TEST_ASSERT(cxMapSize(map) == 3);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 47);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "abc") == 11);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "efg") == 1337);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_insert_array_and_set_keys) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    CX_TEST_DO {
        int arr[] = { 13, 21, 34, 55, 89 };
        CX_TEST_ASSERT(5 == cxListAddArray(list, arr, 5));
        CX_TEST_ASSERT(5 == cxListSize(list));
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 0, "xyz"));
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 1, "abc"));
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 2, "def"));
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 3, "ghi"));
        CX_TEST_ASSERT(0 == cxKvListSetKey(list, 4, "jkl"));

        CxMap *map = cxKvListAsMap(list);
        CX_TEST_ASSERT(5 == cxMapSize(map));
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 13);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "abc") == 21);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "def") == 34);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "ghi") == 55);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "jkl") == 89);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_list_remove_destr_in_list) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxListAdd(list, &x));
        cxKvListSetKey(list, 0, "xyz");

        cxDefineDestructor(list, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        CX_TEST_ASSERT(0 == cxListRemove(list, 0));
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xabcd);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_list_remove_destr_in_map) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxListAdd(list, &x));
        cxKvListSetKey(list, 0, "xyz");
        CxMap *map = cxKvListAsMap(list);
        cxDefineDestructor(map, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        CX_TEST_ASSERT(0 == cxListRemove(list, 0));
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xabcd);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_map_remove_destr_in_list) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        CxList *list = cxKvListAsList(map);
        cxDefineDestructor(list, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xabcd);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_map_remove_destr_in_map) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));

        cxDefineDestructor(map, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xabcd);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_list_remove_destr2_in_list) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxListAdd(list, &x));
        cxKvListSetKey(list, 0, "xyz");

        cxDefineAdvancedDestructor(list, kv_list_test_destr2, (void*)0xef47);
        kv_list_test_destr2_val = 0;
        kv_list_test_destr2_extra = NULL;
        CX_TEST_ASSERT(0 == cxListRemove(list, 0));
        CX_TEST_ASSERT(kv_list_test_destr2_val == 0xabcd);
        CX_TEST_ASSERT(kv_list_test_destr2_extra == (void*)0xef47);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_list_remove_destr2_in_map) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxListAdd(list, &x));
        cxKvListSetKey(list, 0, "xyz");
        CxMap *map = cxKvListAsMap(list);
        cxDefineAdvancedDestructor(map, kv_list_test_destr2, (void*)0xef47);
        kv_list_test_destr2_val = 0;
        kv_list_test_destr2_extra = NULL;
        CX_TEST_ASSERT(0 == cxListRemove(list, 0));
        CX_TEST_ASSERT(kv_list_test_destr2_val == 0xabcd);
        CX_TEST_ASSERT(kv_list_test_destr2_extra == (void*)0xef47);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_map_remove_destr2_in_list) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        CxList *list = cxKvListAsList(map);
        cxDefineAdvancedDestructor(list, kv_list_test_destr2, (void*)0xef47);
        kv_list_test_destr2_val = 0;
        kv_list_test_destr2_extra = NULL;
        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(kv_list_test_destr2_val == 0xabcd);
        CX_TEST_ASSERT(kv_list_test_destr2_extra == (void*)0xef47);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_map_remove_destr2_in_map) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));

        cxDefineAdvancedDestructor(map, kv_list_test_destr2, (void*)0xef47);
        kv_list_test_destr2_val = 0;
        kv_list_test_destr2_extra = NULL;
        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(kv_list_test_destr2_val == 0xabcd);
        CX_TEST_ASSERT(kv_list_test_destr2_extra == (void*)0xef47);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_list_clear_destr_in_list) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxListAdd(list, &x));
        cxKvListSetKey(list, 0, "xyz");

        cxDefineDestructor(list, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        cxListClear(list);
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xabcd);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_list_clear_destr_in_map) {
    CxList *list = cxKvListCreateSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxListAdd(list, &x));
        cxKvListSetKey(list, 0, "xyz");
        CxMap *map = cxKvListAsMap(list);
        cxDefineDestructor(map, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        cxListClear(list);
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xabcd);
    }
    cxListFree(list);
}

CX_TEST(test_kv_list_map_clear_destr_in_list) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        CxList *list = cxKvListAsList(map);
        cxDefineDestructor(list, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        cxMapClear(map);
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xabcd);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_map_clear_destr_in_map) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));

        cxDefineDestructor(map, kv_list_test_destr);
        kv_list_test_destr_val = 0;
        cxMapClear(map);
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xabcd);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_destr_ptr) {
    CxMap *map = cxKvListCreateAsMapSimple(CX_STORE_POINTERS);
    cxDefineDestructor(map, kv_list_test_destr);
    int x;
    CX_TEST_DO {
        x = 0xabcd;
        CX_TEST_ASSERT(0 == cxMapPut(map, "xyz", &x));
        x = 0xef89;
        kv_list_test_destr_val = 0;
        CX_TEST_ASSERT(0 == cxMapRemove(map, "xyz"));
        CX_TEST_ASSERT(kv_list_test_destr_val == 0xef89);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_map_iterator) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    CX_TEST_DO {
        int x;
        x = 0xc0ffee; // this element shall be skipped
        cxListAdd(cxKvListAsList(map), &x);
        x = 815;
        cxMapPut(map, "xyz", &x);
        x = 8016;
        cxMapPut(map, "abcd", &x);
        x = 0xbeef;
        cxListAdd(cxKvListAsList(map), &x);
        x = 80017;
        cxMapPut(map, "efghi", &x);

        const CxMapEntry *entry;
        CxMapIterator it = cxMapIterator(map);
        CX_TEST_ASSERT(it.elem_count == 3);
        CX_TEST_ASSERT(it.elem_size == sizeof(CxMapEntry));

        CX_TEST_ASSERT(cxIteratorValid(it));
        CX_TEST_ASSERT(it.index == 0);
        entry = cxIteratorCurrent(it);
        CX_TEST_ASSERT(*(int*)entry->value == 815);
        CX_TEST_ASSERT(entry->key->len == 3);
        CX_TEST_ASSERT(strncmp(entry->key->data, "xyz", 3) == 0);

        cxIteratorNext(it);
        CX_TEST_ASSERT(cxIteratorValid(it));
        CX_TEST_ASSERT(it.index == 1);
        entry = cxIteratorCurrent(it);
        CX_TEST_ASSERT(*(int*)entry->value == 8016);
        CX_TEST_ASSERT(entry->key->len == 4);
        CX_TEST_ASSERT(strncmp(entry->key->data, "abcd", 4) == 0);

        cxIteratorNext(it);
        CX_TEST_ASSERT(cxIteratorValid(it));
        CX_TEST_ASSERT(it.index == 2);
        entry = cxIteratorCurrent(it);
        CX_TEST_ASSERT(*(int*)entry->value == 80017);
        CX_TEST_ASSERT(entry->key->len == 5);
        CX_TEST_ASSERT(strncmp(entry->key->data, "efghi", 5) == 0);

        cxIteratorNext(it);
        CX_TEST_ASSERT(!cxIteratorValid(it));

        // remove the first element (which was skipped anyway) and try again
        cxListRemove(cxKvListAsList(map), 0);
        it = cxMapIteratorKeys(map);
        CX_TEST_ASSERT(it.elem_count == 3);
        CX_TEST_ASSERT(it.elem_size == sizeof(CxHashKey));

        CX_TEST_ASSERT(cxIteratorValid(it));
        CX_TEST_ASSERT(it.index == 0);
        CxHashKey *key = cxIteratorCurrent(it);
        CX_TEST_ASSERT(key->len == 3);
        CX_TEST_ASSERT(strncmp(key->data, "xyz", 3) == 0);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_map_iterator_no_keys) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    CX_TEST_DO {
        CxList *list = cxKvListAsList(map);
        int x;
        x = 815;
        cxListAdd(list, &x);
        x = 8016;
        cxListAdd(list, &x);
        x = 80017;
        cxMapPut(map, "xyz", &x);
        cxKvListRemoveKey(list, 2);

        // only contains items without keys
        CxMapIterator it = cxMapIterator(map);
        CX_TEST_ASSERT(it.elem_count == 0);
        CX_TEST_ASSERT(!cxIteratorValid(it));
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_map_iterator_remove) {
    CxMap *map = cxKvListCreateAsMapSimple(CX_STORE_POINTERS);
    int x, y, z;
    CX_TEST_DO {
        cxDefineDestructor(map, kv_list_test_destr);
        x = 815;
        cxMapPut(map, "xyz", &x);
        y = 8016;
        cxMapPut(map, "abcd", &y);
        z = 80017;
        cxMapPut(map, "efghi", &z);

        kv_list_test_destr_val = 0;
        CxMapIterator iter = cxMapIteratorValues(map);
        cx_foreach(int *, elem, iter) {
            if (*elem == 8016) {
                cxIteratorFlagRemoval(iter);
            }
        }

        CX_TEST_ASSERT(kv_list_test_destr_val == 8016);
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(cxMapGet(map, "abcd") == NULL);
        CxList *list = cxKvListAsList(map);
        CX_TEST_ASSERT(cxListSize(list) == 2);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 0) == 815);
        CX_TEST_ASSERT(*(int*)cxListAt(list, 1) == 80017);
    }
    cxMapFree(map);
}

CX_TEST(test_kv_list_list_iterator_remove) {
    CxMap *map = cxKvListCreateAsMapSimple(sizeof(int));
    CX_TEST_DO {
        cxDefineAdvancedDestructor(map, kv_list_test_destr2, (void*)0xf00);
        int x;
        x = 815;
        cxMapPut(map, "xyz", &x);
        x = 8016;
        cxMapPut(map, "abcd", &x);
        x = 80017;
        cxMapPut(map, "efghi", &x);

        CxList *list = cxKvListAsList(map);
        kv_list_test_destr2_val = 0;
        kv_list_test_destr2_extra = NULL;
        CxIterator iter = cxListIterator(list);
        cx_foreach(int *, elem, iter) {
            if (*elem == 8016) {
                cxIteratorFlagRemoval(iter);
            }
        }

        CX_TEST_ASSERT(kv_list_test_destr2_val == 8016);
        CX_TEST_ASSERT(kv_list_test_destr2_extra == (void*)0xf00);
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        CX_TEST_ASSERT(cxMapGet(map, "abcd") == NULL);
        CX_TEST_ASSERT(cxListSize(list) == 2);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "xyz") == 815);
        CX_TEST_ASSERT(*(int*)cxMapGet(map, "efghi") == 80017);
    }
    cxMapFree(map);
}

CxTestSuite *cx_test_suite_kv_list_specifics(void) {
    CxTestSuite *suite = cx_test_suite_new("kv_list specifics");

    cx_test_register(suite, test_kv_list_map_as_list);
    cx_test_register(suite, test_kv_list_free_as_map);
    cx_test_register(suite, test_kv_list_free_as_list);
    cx_test_register(suite, test_kv_list_remove);
    cx_test_register(suite, test_kv_list_find_and_remove);
    cx_test_register(suite, test_kv_list_remove_and_get);
    cx_test_register(suite, test_kv_list_remove_array);
    cx_test_register(suite, test_kv_list_remove_array_and_get);
    cx_test_register(suite, test_kv_list_map_put);
    cx_test_register(suite, test_kv_list_map_put_ptr);
    cx_test_register(suite, test_kv_list_map_put_not_hashed);
    cx_test_register(suite, test_kv_list_map_put_overwrite);
    cx_test_register(suite, test_kv_list_map_remove);
    cx_test_register(suite, test_kv_list_map_remove_and_get);
    cx_test_register(suite, test_kv_list_set_key);
    cx_test_register(suite, test_kv_list_set_key_already_exists);
    cx_test_register(suite, test_kv_list_set_key_again);
    cx_test_register(suite, test_kv_list_remove_key);
    cx_test_register(suite, test_kv_list_get_key);
    cx_test_register(suite, test_kv_list_insert_with_key);
    cx_test_register(suite, test_kv_list_insert_ptr_with_key);
    cx_test_register(suite, test_kv_list_insert_array_and_set_keys);
    cx_test_register(suite, test_kv_list_list_remove_destr_in_list);
    cx_test_register(suite, test_kv_list_list_remove_destr_in_map);
    cx_test_register(suite, test_kv_list_map_remove_destr_in_list);
    cx_test_register(suite, test_kv_list_map_remove_destr_in_map);
    cx_test_register(suite, test_kv_list_list_remove_destr2_in_list);
    cx_test_register(suite, test_kv_list_list_remove_destr2_in_map);
    cx_test_register(suite, test_kv_list_map_remove_destr2_in_list);
    cx_test_register(suite, test_kv_list_map_remove_destr2_in_map);
    cx_test_register(suite, test_kv_list_list_clear_destr_in_list);
    cx_test_register(suite, test_kv_list_list_clear_destr_in_map);
    cx_test_register(suite, test_kv_list_map_clear_destr_in_list);
    cx_test_register(suite, test_kv_list_map_clear_destr_in_map);
    cx_test_register(suite, test_kv_list_destr_ptr);
    cx_test_register(suite, test_kv_list_map_iterator);
    cx_test_register(suite, test_kv_list_map_iterator_no_keys);
    cx_test_register(suite, test_kv_list_map_iterator_remove);
    cx_test_register(suite, test_kv_list_list_iterator_remove);

    return suite;
}