tests/test_properties.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2024 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/properties.h"
#include "cx/hash_map.h"

CX_TEST(test_properties_init) {
    CxProperties prop;
    CX_TEST_DO {
        cxPropertiesInitDefault(&prop);

        CX_TEST_ASSERT(prop.config.delimiter == '=');
        CX_TEST_ASSERT(prop.config.comment1 == '#');
        CX_TEST_ASSERT(prop.config.comment2 == 0);
        CX_TEST_ASSERT(prop.config.comment3 == 0);
        CX_TEST_ASSERT(prop.config.continuation == '\\');
        CX_TEST_ASSERT(prop.input.space == NULL);
        CX_TEST_ASSERT(prop.buffer.space == NULL);

        cxPropertiesDestroy(&prop);
    }
}

CX_TEST(test_properties_next) {
    const char *tests[] = {
        "name = value\n",
        "name=value\n",
        "n=value\n",
        "name=v\n",
        "n=v\n",
        "name = value # comment\n",
        "#comment\nn=v\n",
        "# comment1\n# comment2\n\n    \n\nname = value\n",
        "    name     =      value\n",
        "name = value\n\n"
    };

    const char *keys[] = {
        "name",
        "name",
        "n",
        "name",
        "n",
        "name",
        "n",
        "name",
        "name",
        "name"
    };

    const char *values[] = {
        "value",
        "value",
        "value",
        "v",
        "v",
        "value",
        "v",
        "value",
        "value",
        "value"
    };

    CxProperties prop;
    cxPropertiesInitDefault(&prop);
    CxPropertiesStatus result;
    cxstring key;
    cxstring value;
    CX_TEST_DO {
        for (int i = 0; i < 10; i++) {
            cxPropertiesFill(&prop, tests[i]);
            CX_TEST_ASSERT(prop.input.space == tests[i]);
            CX_TEST_ASSERT(prop.input.size == strlen(tests[i]));
            CX_TEST_ASSERT(prop.input.pos == 0);

            result = cxPropertiesNext(&prop, &key, &value);
            cxstring k = cx_str(keys[i]);
            cxstring v = cx_str(values[i]);
            CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
            CX_TEST_ASSERT(0 == cx_strcmp(key, k));
            CX_TEST_ASSERT(0 == cx_strcmp(value, v));

            result = cxPropertiesNext(&prop, &key, &value);
            CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);
        }
    }
    cxPropertiesDestroy(&prop);
}

CX_TEST_SUBROUTINE(test_properties_next_multi_check, CxProperties *prop) {
    const char *keys[] = {
            "a",
            "b",
            "c",
            "uap",
            "name",
            "key1",
            "key2",
            "key3"
    };

    const char *values[] = {
            "a value",
            "b value",
            "core",
            "core",
            "ucx",
            "value1",
            "value2",
            "value3"
    };
    CxPropertiesStatus result;
    cxstring key;
    cxstring value;
    for (int i = 0; i < 8; i++) {
        result = cxPropertiesNext(prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, cx_str(keys[i])));
        CX_TEST_ASSERT(!cx_strcmp(value, cx_str(values[i])));
    }
    result = cxPropertiesNext(prop, &key, &value);
    CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);
}

CX_TEST(test_properties_next_multi) {
    const char *str = "#\n"
        "# properties\n"
        "# contains key/value pairs\n"
        "#\n"
        "a = a value\n"
        "b = b value\n"
        "c = core\n"
        "\n# test\n"
        "uap = core\n"
        "name = ucx\n"
        "# no = property\n"
        "key1 = value1\n"
        "#key1 = wrong value\n"
        "#key2 = not value 2\n"
        "key2 = value2\n"
        "\n\n\n        \n           key3=value3\n";

    CxProperties prop;
    cxPropertiesInitDefault(&prop);

    CX_TEST_DO {
        CxPropertiesStatus result;
        cxstring key;
        cxstring value;
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NULL_INPUT);

        // check for C string
        cxPropertiesFill(&prop, str);
        CX_TEST_CALL_SUBROUTINE(test_properties_next_multi_check, &prop);

        // check for cxstring
        cxPropertiesFill(&prop, cx_str(str));
        CX_TEST_CALL_SUBROUTINE(test_properties_next_multi_check, &prop);

        // check for mutstr
        cxPropertiesFill(&prop, cx_mutstr((char*)str));
        CX_TEST_CALL_SUBROUTINE(test_properties_next_multi_check, &prop);
    }
    cxPropertiesDestroy(&prop);
}

CX_TEST(test_properties_next_part) {
    CxProperties prop;
    cxPropertiesInitDefault(&prop);
    CxPropertiesStatus result;
    cxstring key;
    cxstring value;
    const char *str;

    CX_TEST_DO {
        str = "";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);

        str = "  \n";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);

        str = "name";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        str = "    ";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        // call fill twice in a row
        str = "= ";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        str = "value";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        str = "\n";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("name")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value")));

        // second round
        str = "#comment\n";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);

        str = "#comment\nname2 = ";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        str = "value2\na = b\n";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("name2")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value2")));

        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("a")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("b")));

        str = "# comment\n#\n#\ntests = ";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        str = "test1 ";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        str = "test2 test3 test4\n";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("tests")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("test1 test2 test3 test4")));

        // test if cxPropertiesNext finds a name/value after a comment
        str = "# just a comment";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        str = " in 3";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        str = " parts\nx = 1\n";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("x")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("1")));

        // finally we are done
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);
    }
    cxPropertiesDestroy(&prop);
}

CX_TEST(test_properties_next_long_lines) {
    CxProperties prop;
    cxPropertiesInitDefault(&prop);
    CxPropertiesStatus result;
    cxstring key;
    cxstring value;

    size_t key_len = 512;
    char *long_key = (char*)malloc(key_len);
    memset(long_key, 'a', 70);
    memset(long_key + 70, 'b', 242);
    memset(long_key + 312, 'c', 200);

    size_t value_len = 2048;
    char *long_value = (char*)malloc(value_len);
    memset(long_value, 'x', 1024);
    memset(long_value+1024, 'y', 1024);

    CX_TEST_DO {
        cxPropertiesFilln(&prop, long_key, 10);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        cxPropertiesFilln(&prop, long_key + 10, 202);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        cxPropertiesFilln(&prop, long_key + 212, 200);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        cxPropertiesFilln(&prop, long_key + 412, 100);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        const char *str = " = ";
        cxPropertiesFill(&prop, str);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        cxPropertiesFilln(&prop, long_value, 512);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        cxPropertiesFilln(&prop, long_value + 512, 1024);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        cxPropertiesFilln(&prop, long_value + 1536, 512);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);

        str = "\n#comment\nkey = value\n";
        cxPropertiesFill(&prop, str);
        result = cxPropertiesNext(&prop, &key, &value);
        cxstring k = cx_strn(long_key, key_len);
        cxstring v = cx_strn(long_value, value_len);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, k));
        CX_TEST_ASSERT(0 == cx_strcmp(value, v));

        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("key")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value")));

        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);

        CX_TEST_ASSERT(prop.buffer.capacity > 0);
        CX_TEST_ASSERT(cxBufferEof(&prop.buffer));
        CX_TEST_ASSERT(cxBufferEof(&prop.input));
        cxPropertiesDestroy(&prop);
        CX_TEST_ASSERT(prop.buffer.capacity == 0);
        CX_TEST_ASSERT(prop.buffer.size == 0);
        CX_TEST_ASSERT(prop.buffer.pos == 0);
    }

    free(long_key);
    free(long_value);
}

CX_TEST(test_properties_next_starts_with_newlines) {
    const char *str1 = "key1 = value1";
    const char *str2 = "\nkey2 = value2\n";

    CxProperties prop;
    cxPropertiesInitDefault(&prop);

    cxstring key;
    cxstring value;

    CX_TEST_DO {
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str1));
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_INCOMPLETE_DATA);
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str2));
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key1"));
        CX_TEST_ASSERT(!cx_strcmp(value, "value1"));
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key2"));
        CX_TEST_ASSERT(!cx_strcmp(value, "value2"));
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_DATA);
    }

    cxPropertiesDestroy(&prop);
}

CX_TEST(test_properties_next_line_continuation) {
    const char *str = 
        "key1 = multiline \\\nvalue\n"
        "key2 = normal\n"
        "key3 = multiline \\\n  trim  \n"
        "key4 = m1\\\nm2\\\n  m3\\\nm4  \n"
        "key5 = no\\continuation\n"
        "key6 = multiple \\\n \\\n \\\n continuations\n";
    
    CxProperties prop;
    cxPropertiesInitDefault(&prop);
    
    cxstring key;
    cxstring value;
    
    CX_TEST_DO {
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key1"));
        CX_TEST_ASSERT(!cx_strcmp(value, "multiline value"));
        
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key2"));
        CX_TEST_ASSERT(!cx_strcmp(value, "normal"));
        
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key3"));
        CX_TEST_ASSERT(!cx_strcmp(value, "multiline trim"));
        
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key4"));
        CX_TEST_ASSERT(!cx_strcmp(value, "m1m2m3m4"));
        
        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key5"));
        CX_TEST_ASSERT(!cx_strcmp(value, "no\\continuation"));

        CX_TEST_ASSERT(cxPropertiesNext(&prop, &key,  &value) == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key6"));
        CX_TEST_ASSERT(!cx_strcmp(value, "multiple continuations"));
    }
    
    cxPropertiesDestroy(&prop);
}

CX_TEST(test_properties_next_line_continuation_part) {
    CxProperties prop;
    cxPropertiesInitDefault(&prop);
    
    cxstring key;
    cxstring value;
    CxPropertiesStatus result;
    const char *str;
    
    CX_TEST_DO {
        // key1 = continue continue ...line
        str = "key1 ";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);
        
        str = "= continue \\";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);
        
        str = "\ncontinue \\\n";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);
        
        str = "...";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);
        
        str = "line\nkey2 = value2\n";
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, str));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key1"));
        CX_TEST_ASSERT(!cx_strcmp(value, "continue continue ...line"));
        
        // key2 = value2
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(!cx_strcmp(key, "key2"));
        CX_TEST_ASSERT(!cx_strcmp(value, "value2"));
        
        // key3 = continue-line
        str = "key3=\\\ncontinue-\\\n   line";
        size_t len = strlen(str);
        for(size_t i=0;i<len;i++) {
            CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, cx_strn(str+i, 1)));
            result = cxPropertiesNext(&prop, &key,  &value);
            CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);
        }
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, "\n"));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "key3"));
        CX_TEST_ASSERT(!cx_strcmp(value, "continue-line"));
    }
    
    cxPropertiesDestroy(&prop);
}

CX_TEST(test_properties_next_alternative_delimiter) {
    CxProperties prop;
    CxPropertiesConfig alt_config = {0};
    alt_config.delimiter = ':';
    cxPropertiesInit(&prop, alt_config);
    
    cxstring key;
    cxstring value;
    CxPropertiesStatus result;
    
    CX_TEST_DO {
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, "no_delimiter = value\n"));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INVALID_MISSING_DELIMITER);
        cxPropertiesReset(&prop);
        CX_TEST_ASSERT(0 == cxPropertiesFill(&prop, "correct : value\n"));
        result = cxPropertiesNext(&prop, &key,  &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(!cx_strcmp(key, "correct"));
        CX_TEST_ASSERT(!cx_strcmp(value, "value"));
    }
    cxPropertiesDestroy(&prop);
}

static FILE *cx_opentmp(char *tpl) {
#ifdef WITH_MKSTEMP
    strcpy(tpl, "ucxtestXXXXXX");
    int fd = mkstemp(tpl);
    if (fd < 0) return NULL;
    return fdopen(fd, "w");
#else
    char *fname = tmpnam(tpl);
    return fname == NULL ? NULL : fopen(fname, "wx");
#endif
}

CX_TEST(test_properties_load) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    char fname[L_tmpnam];
    FILE *f = cx_opentmp(fname);
    bool rmtmp = false;
    CX_TEST_DO {
        CX_TEST_ASSERTM(f, "test file cannot be opened, test aborted");
        rmtmp = true;
        fprintf(f, "# properties file\n\nkey1 = value1\nkey2 = value2\n");
        fprintf(f, "\n\nkey3    = value3\n\n");

        size_t key_len = 512;
        char *long_key = (char *) malloc(key_len);
        memset(long_key, 'k', 512);

        size_t value_len = 2048;
        char *long_value = (char *) malloc(value_len);
        memset(long_value, 'v', 2048);

        fwrite(long_key, 1, key_len, f);
        fprintf(f, "    =    ");
        fwrite(long_value, 1, value_len, f);
        fprintf(f, "                         \n");

        fprintf(f, "\n\n\n\nlast_key = property value\n");
        fclose(f);
        f = NULL;
        // preparation of test file complete

        // we want to load the properties into a map of char* pointers
        CxMap *map = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
        cxSetAdvancedDestructor(map, cxFree, &talloc);
        CxPropertiesStatus status = cxPropertiesLoadDefault(&talloc.base, fname, map);

        CX_TEST_ASSERT(status == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(cxMapSize(map) == 5);

        char *v1 = cxMapGet(map, "key1");
        char *v2 = cxMapGet(map, cx_str("key2"));
        char *v3 = cxMapGet(map, "key3");
        char *lv = cxMapGet(map, cx_strn(long_key, key_len));
        char *lk = cxMapGet(map, "last_key");

        CX_TEST_ASSERTM(v1, "value for key1 not found");
        CX_TEST_ASSERTM(v2, "value for key2 not found");
        CX_TEST_ASSERTM(v3, "value for key3 not found");
        CX_TEST_ASSERTM(lv, "value for long key not found");
        CX_TEST_ASSERTM(lk, "value for last_key not found");

        CX_TEST_ASSERT(!strcmp(v1, "value1"));
        CX_TEST_ASSERT(!strcmp(v2, "value2"));
        CX_TEST_ASSERT(!strcmp(v3, "value3"));
        cxstring expected = cx_strn(long_value, value_len);
        cxstring actual = cx_str(lv);
        CX_TEST_ASSERT(!cx_strcmp(expected, actual));
        CX_TEST_ASSERT(!strcmp(lk, "property value"));

        free(long_key);
        free(long_value);
        CX_TEST_ASSERT(cx_testing_allocator_used(&talloc));
        cxMapFree(map);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
    if (f) fclose(f);
    if (rmtmp) remove(fname);
}

CX_TEST(test_properties_load_empty_file) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    char fname[L_tmpnam];
    FILE *f = cx_opentmp(fname);
    bool rmtmp = false;
    CX_TEST_DO {
        CX_TEST_ASSERTM(f, "test file cannot be opened, test aborted");
        rmtmp = true;
        fclose(f);
        f = NULL;

        CxMap *map = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
        // store something that we don't want to be deleted
        cxMapPut(map, "test", "value");
        CxPropertiesStatus status = cxPropertiesLoadDefault(&talloc.base, fname, map);
        CX_TEST_ASSERT(status == CX_PROPERTIES_NO_DATA);
        CX_TEST_ASSERT(cxMapSize(map) == 1);

        char *v = cxMapGet(map, "test");
        CX_TEST_ASSERTM(v, "value was removed");
        CX_TEST_ASSERT(!strcmp(v, "value"));
        CX_TEST_ASSERT(!cx_testing_allocator_used(&talloc));
        cxMapFree(map);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
    if (f) fclose(f);
    if (rmtmp) remove(fname);
}

CX_TEST(test_properties_load_only_comments) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    char fname[L_tmpnam];
    FILE *f = cx_opentmp(fname);
    bool rmtmp = false;
    CX_TEST_DO {
        CX_TEST_ASSERTM(f, "test file cannot be opened, test aborted");
        rmtmp = true;
        fputs("# test file\n\n# contains only comments\n\n# key = value\n", f);
        fclose(f);
        f = NULL;

        CxMap *map = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
        CxPropertiesStatus status = cxPropertiesLoadDefault(&talloc.base, fname, map);
        CX_TEST_ASSERT(status == CX_PROPERTIES_NO_DATA);
        CX_TEST_ASSERT(cxMapSize(map) == 0);

        CX_TEST_ASSERT(!cx_testing_allocator_used(&talloc));
        cxMapFree(map);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
    if (f) fclose(f);
    if (rmtmp) remove(fname);
}

CX_TEST(test_properties_load_error) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    char fname[L_tmpnam];
    FILE *f = cx_opentmp(fname);
    bool rmtmp = false;
    CX_TEST_DO {
        CX_TEST_ASSERTM(f, "test file cannot be opened, test aborted");
        rmtmp = true;
        fputs("# test file\n\ntest = value\n = value2\n", f);
        fclose(f);
        f = NULL;

        CxMap *map = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
        cxSetAdvancedDestructor(map, cxFree, &talloc);
        CxPropertiesStatus status = cxPropertiesLoadDefault(&talloc.base, fname, map);
        CX_TEST_ASSERT(status == CX_PROPERTIES_INVALID_EMPTY_KEY);
        // all keys that could be successfully parsed are added
        CX_TEST_ASSERT(cxMapSize(map) == 1);
        char *v = cxMapGet(map, "test");
        CX_TEST_ASSERT(v != NULL);
        CX_TEST_ASSERT(!strcmp(v, "value"));

        cxMapFree(map);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
    if (f) fclose(f);
    if (rmtmp) remove(fname);
}

CX_TEST(test_properties_load_file_not_exists) {
    CX_TEST_DO {
        CxMap *map = cxHashMapCreate(NULL, CX_STORE_POINTERS, 0);
        CxPropertiesStatus status = cxPropertiesLoadDefault(NULL, "does-definitely-not-exist", map);
        CX_TEST_ASSERT(status == CX_PROPERTIES_FILE_ERROR);
        cxMapFree(map);
    }
}

CX_TEST(test_properties_load_cxmutstr_map) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    char fname[L_tmpnam];
    FILE *f = cx_opentmp(fname);
    bool rmtmp = false;
    CX_TEST_DO {
        CX_TEST_ASSERTM(f, "test file cannot be opened, test aborted");
        rmtmp = true;
        fputs("# test file\n\ntest = value\ntest2 = value2\n", f);
        fclose(f);
        f = NULL;

        CxMap *map = cxHashMapCreate(NULL, sizeof(cxmutstr), 0);
        cxSetAdvancedDestructor(map, cx_strfree_a, &talloc);
        CxPropertiesStatus status = cxPropertiesLoadDefault(&talloc.base, fname, map);
        CX_TEST_ASSERT(status == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(cxMapSize(map) == 2);
        cxstring v1 = cx_str("value");
        cxstring v2 = cx_str("value2");
        CX_TEST_ASSERT(cx_strcmp_p(cxMapGet(map, "test"), &v1) == 0);
        CX_TEST_ASSERT(cx_strcmp_p(cxMapGet(map, "test2"), &v2) == 0);

        CX_TEST_ASSERT(cx_testing_allocator_used(&talloc));
        cxMapFree(map);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
    if (f) fclose(f);
    if (rmtmp) remove(fname);
}

CX_TEST(test_properties_load_incompatible_map) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    char fname[L_tmpnam];
    FILE *f = cx_opentmp(fname);
    bool rmtmp = false;
    CX_TEST_DO {
        CX_TEST_ASSERTM(f, "test file cannot be opened, test aborted");
        rmtmp = true;
        fputs("# test file\n\ntest = value\ntest2 = value2\n", f);
        fclose(f);
        f = NULL;

        CxMap *map = cxHashMapCreate(NULL, sizeof(CxBuffer), 0);
        cxSetAdvancedDestructor(map, cxFree, &talloc);
        CxPropertiesStatus status = cxPropertiesLoadDefault(&talloc.base, fname, map);
        CX_TEST_ASSERT(status == CX_PROPERTIES_MAP_ERROR);
        CX_TEST_ASSERT(cxMapSize(map) == 0);

        cxMapFree(map);
        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
    if (f) fclose(f);
    if (rmtmp) remove(fname);
}

CX_TEST(test_properties_multiple_fill) {
    const char *props1 = "key1 = value1\n";
    const char *props2 = "key2 = value2\n";
    const char *props3 = "key3 = value3\n";

    CxProperties prop;
    cxPropertiesInitDefault(&prop);
    CxPropertiesStatus result;
    cxstring key;
    cxstring value;
    CX_TEST_DO {
        cxPropertiesFill(&prop, props1);
        cxPropertiesFill(&prop, props2);
        cxPropertiesFill(&prop, props3);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("key1")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value1")));
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("key2")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value2")));
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("key3")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value3")));

        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);
    }
    cxPropertiesDestroy(&prop);
}

CX_TEST(test_properties_use_stack) {
    const char *props1 = "key1 = val";
    const char *props2 = "ue1\nkey2 = value2";
    const char *props3 = "\nkey3 = value3\n";
    char stackmem[16];

    CxProperties prop;
    cxPropertiesInitDefault(&prop);
    cxPropertiesUseStack(&prop, stackmem, 16);
    CxPropertiesStatus result;
    cxstring key;
    cxstring value;
    CX_TEST_DO {
        cxPropertiesFill(&prop, props1);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);
        cxPropertiesFill(&prop, props2);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("key1")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value1")));
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INCOMPLETE_DATA);
        cxPropertiesFill(&prop, props3);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("key2")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value2")));
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("key3")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("value3")));
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_DATA);
    }
    cxPropertiesDestroy(&prop);
}

CX_TEST(test_properties_empty_key) {
    const char *fail1 = "= val\n";
    const char *fail2 = "   = val\n";
    const char *good = "  key = val\n";

    CxProperties prop;
    CxPropertiesStatus result;
    cxstring key;
    cxstring value;
    CX_TEST_DO {
        cxPropertiesInitDefault(&prop);
        cxPropertiesFill(&prop, fail1);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INVALID_EMPTY_KEY);
        cxPropertiesReset(&prop);
        cxPropertiesFill(&prop, fail2);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_INVALID_EMPTY_KEY);
        cxPropertiesReset(&prop);
        cxPropertiesFill(&prop, good);
        result = cxPropertiesNext(&prop, &key, &value);
        CX_TEST_ASSERT(result == CX_PROPERTIES_NO_ERROR);
        CX_TEST_ASSERT(0 == cx_strcmp(key, cx_str("key")));
        CX_TEST_ASSERT(0 == cx_strcmp(value, cx_str("val")));
        cxPropertiesDestroy(&prop);
    }
}

CxTestSuite *cx_test_suite_properties(void) {
    CxTestSuite *suite = cx_test_suite_new("properties");

    cx_test_register(suite, test_properties_init);
    cx_test_register(suite, test_properties_next);
    cx_test_register(suite, test_properties_next_multi);
    cx_test_register(suite, test_properties_next_part);
    cx_test_register(suite, test_properties_next_long_lines);
    cx_test_register(suite, test_properties_next_starts_with_newlines);
    cx_test_register(suite, test_properties_next_line_continuation);
    cx_test_register(suite, test_properties_next_line_continuation_part);
    cx_test_register(suite, test_properties_next_alternative_delimiter);
    cx_test_register(suite, test_properties_load);
    cx_test_register(suite, test_properties_load_empty_file);
    cx_test_register(suite, test_properties_load_only_comments);
    cx_test_register(suite, test_properties_load_error);
    cx_test_register(suite, test_properties_load_file_not_exists);
    cx_test_register(suite, test_properties_load_cxmutstr_map);
    cx_test_register(suite, test_properties_load_incompatible_map);
    cx_test_register(suite, test_properties_multiple_fill);
    cx_test_register(suite, test_properties_use_stack);
    cx_test_register(suite, test_properties_empty_key);

    return suite;
}