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"

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_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_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_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"));

        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);
    }
    cxListFree(list);
}


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

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_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);
}

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_map_put);
    cx_test_register(suite, test_kv_list_map_remove);
    cx_test_register(suite, test_kv_list_set_key);
    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_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);

    return suite;
}