Mercurial > hg > ucx / file revision

/*
 * 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 "util_allocator.h"
#include "cx/test.h"

#include "cx/json.h"
#include "cx/mempool.h"

CX_TEST(test_json_init_default) {
    CxJson json;
    CX_TEST_DO {
        cxJsonInit(&json, NULL);
        CX_TEST_ASSERT(json.states == json.states_internal);
        CX_TEST_ASSERT(json.states_size == 1);
        CX_TEST_ASSERT(json.states_capacity >= 8);
        CX_TEST_ASSERT(json.vbuf == json.vbuf_internal);
        CX_TEST_ASSERT(json.vbuf_size == 0);
        CX_TEST_ASSERT(json.vbuf_capacity >= 8);
        cxJsonDestroy(&json);
    }
}

CX_TEST(test_json_simple_object) {
    cxstring text = cx_str(
            "{\n"
            "\t\"message\":\"success\",\n"
            "\t\"position\":{\n"
            "\t\t\"longitude\":-94.7099,\n"
            "\t\t\"latitude\":51.5539\n"
            "\t},\n"
            "\t\"timestamp\":1729348561,\n"
            "\t\"alive\":true\n"
            "}"
    );

    CX_TEST_DO {
        CxJsonStatus result;

        CxJson json;
        cxJsonInit(&json, NULL);
        cxJsonFill(&json, text);

        // parse the big fat object
        CxJsonValue *obj;
        result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);

        // check the contents
        CX_TEST_ASSERT(cxJsonIsObject(obj));

        CxJsonValue *message = cxJsonObjGet(obj, "message");
        CX_TEST_ASSERT(cxJsonIsString(message));
        CX_TEST_ASSERT(0 == cx_strcmp(
                cxJsonAsCxString(message),
                cx_str("success"))
        );

        CxJsonValue *position = cxJsonObjGet(obj, "position");
        CX_TEST_ASSERT(cxJsonIsObject(position));
        CxJsonValue *longitude = cxJsonObjGet(position, "longitude");
        CX_TEST_ASSERT(cxJsonIsNumber(longitude));
        CX_TEST_ASSERT(!cxJsonIsInteger(longitude));
        CX_TEST_ASSERT(cxJsonAsDouble(longitude) == -94.7099);
        CX_TEST_ASSERT(cxJsonAsInteger(longitude) == -94);
        CxJsonValue *latitude = cxJsonObjGet(position, "latitude");
        CX_TEST_ASSERT(cxJsonIsNumber(latitude));
        CX_TEST_ASSERT(!cxJsonIsInteger(latitude));
        CX_TEST_ASSERT(cxJsonAsDouble(latitude) == 51.5539);
        CX_TEST_ASSERT(cxJsonAsInteger(latitude) == 51);

        CxJsonValue *timestamp = cxJsonObjGet(obj, "timestamp");
        CX_TEST_ASSERT(cxJsonIsInteger(timestamp));
        CX_TEST_ASSERT(cxJsonIsNumber(timestamp));
        CX_TEST_ASSERT(cxJsonAsInteger(timestamp) == 1729348561);
        CX_TEST_ASSERT(cxJsonAsDouble(timestamp) == 1729348561.0);

        CxJsonValue *alive = cxJsonObjGet(obj, "alive");
        CX_TEST_ASSERT(cxJsonIsBool(alive));
        CX_TEST_ASSERT(cxJsonIsTrue(alive));
        CX_TEST_ASSERT(!cxJsonIsFalse(alive));
        CX_TEST_ASSERT(cxJsonAsBool(alive));

        // this recursively frees everything else
        cxJsonValueFree(obj);

        // we only have one object that already contained all the data
        result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_NO_DATA);

        cxJsonDestroy(&json);
    }
}

CX_TEST(test_json_escaped_strings) {
    cxstring text = cx_str(
            "{\n"
            "\t\"object\":\"{\\n\\t\\\"object\\\":null\\n}\"}\"\n"
            "}"
    );

    CxJson json;
    cxJsonInit(&json, NULL);
    CX_TEST_DO {
        cxJsonFill(&json, text);
        CxJsonValue *obj;
        CxJsonStatus result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsObject(obj));
        CxJsonValue *object = cxJsonObjGet(obj, "object");
        CX_TEST_ASSERT(cxJsonIsString(object));
        CX_TEST_ASSERT(0 == cx_strcmp(
            cxJsonAsCxString(object),
            CX_STR("{\n\t\"object\":null\n}"))
        );
        cxJsonValueFree(obj);
    }
    cxJsonDestroy(&json);
}

CX_TEST(test_json_object_incomplete_token) {
    cxstring text = cx_str(
            "{\"message\":\"success\"  ,     \"__timestamp\":1729348561}");
    cxstring parts[16];
    size_t nparts = 0; // split the json text into mulple parts
    for(size_t i=0;i<text.length;i+=4) {
        parts[nparts++] = cx_strsubsl(text, i, 4);
    }
    
    CX_TEST_DO {
        CxJsonStatus result;

        CxJson json;
        cxJsonInit(&json, NULL);
        CxJsonValue *obj;
        
        size_t part = 0;
        while(part < nparts - 1) {
            cxJsonFill(&json, parts[part]);
            part++;
            result = cxJsonNext(&json, &obj);
            CX_TEST_ASSERT(result == CX_JSON_INCOMPLETE_DATA);
        }
        cxJsonFill(&json, parts[nparts - 1]);
        result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsObject(obj));
        
        CxJsonValue *message = cxJsonObjGet(obj, "message");
        CX_TEST_ASSERT(cxJsonIsString(message));
        CX_TEST_ASSERT(0 == cx_strcmp(
                cxJsonAsCxString(message),
                cx_str("success"))
        );
        CxJsonValue *timestamp = cxJsonObjGet(obj, "__timestamp");
        CX_TEST_ASSERT(message->type == CX_JSON_STRING);
        CX_TEST_ASSERT(cxJsonIsInteger(timestamp));
        CX_TEST_ASSERT(cxJsonAsInteger(timestamp) == 1729348561);
        
        // this recursively frees everything else
        cxJsonValueFree(obj);

        // now there is everything read
        result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_NO_DATA);

        cxJsonDestroy(&json);
    }
}

CX_TEST(test_json_token_wrongly_completed) {
    cxstring text = cx_str("{\"number\": 47110815!}");
    cxstring part1 = cx_strsubsl(text, 0, 16);
    cxstring part2 = cx_strsubs(text, 16);

    CxJson json;
    cxJsonInit(&json, NULL);
    CX_TEST_DO {
        CxJsonStatus result;
        CxJsonValue *obj;

        cxJsonFill(&json, part1);
        result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_INCOMPLETE_DATA);
        cxJsonFill(&json, part2);
        result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_FORMAT_ERROR_NUMBER);
        CX_TEST_ASSERT(obj->type == CX_JSON_NOTHING);
    }
    cxJsonDestroy(&json);
}

CX_TEST(test_json_subsequent_fill) {
    cxstring text = cx_str(
            "{\"message\":\"success\"  ,     \"__timestamp\":1729348561}");

    cxstring part1 = cx_strsubsl(text, 0, 25);
    cxstring part2 = cx_strsubs(text, 25);

    CX_TEST_DO {
        CxJson json;
        cxJsonInit(&json, NULL);
        CxJsonValue *obj;

        cxJsonFill(&json, part1);
        cxJsonFill(&json, part2);
        CxJsonStatus result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsObject(obj));

        CxJsonValue *message = cxJsonObjGet(obj, "message");
        CX_TEST_ASSERT(cxJsonIsString(message));
        CX_TEST_ASSERT(0 == cx_strcmp(
                cxJsonAsCxString(message),
                cx_str("success"))
        );
        CxJsonValue *timestamp = cxJsonObjGet(obj, "__timestamp");
        CX_TEST_ASSERT(message->type == CX_JSON_STRING);
        CX_TEST_ASSERT(cxJsonIsInteger(timestamp));
        CX_TEST_ASSERT(cxJsonAsInteger(timestamp) == 1729348561);

        cxJsonValueFree(obj);
        result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_NO_DATA);

        cxJsonDestroy(&json);
    }
}

CX_TEST(test_json_object_error) {
    cxstring text0 = cx_str(
            "{\n"
            "\t\"message\":\"success\",\n"
            "\t\"data\":{\n"
            "\t\t\"obj\":{\n"
            "\t\t\t\"array\": [1, 2, 3, ?syntaxerror? ]\n"
            "\t\t\"}\n"
            "\t},\n"
            "\t\"timestamp\":1729348561,\n"
            "}"
    );
    cxstring text1 = cx_str("{ \"string\" }");
    cxstring text2 = cx_str("{ \"a\" : }");
    cxstring text3 = cx_str("{ \"a\" : \"b\" ]");
    cxstring text4 = cx_str("{ \"name\": \"value\" ]");
    
    cxstring tests[] = { text0, text1, text2, text3, text4 };
    CxJsonStatus errors[] = {
        CX_JSON_FORMAT_ERROR_NUMBER,
        CX_JSON_FORMAT_ERROR_UNEXPECTED_TOKEN,
        CX_JSON_FORMAT_ERROR_UNEXPECTED_TOKEN,
        CX_JSON_FORMAT_ERROR_UNEXPECTED_TOKEN,
        CX_JSON_FORMAT_ERROR_UNEXPECTED_TOKEN
    };
    
    CX_TEST_DO {
        CxJsonStatus result;
        CxJson json;
        CxJsonValue *obj = NULL;
        
        for(int i=0;i<5;i++) {
            cxJsonInit(&json, NULL);
            cxJsonFill(&json, tests[i]);
            result = cxJsonNext(&json, &obj);

            CX_TEST_ASSERT(result == errors[i]);
            CX_TEST_ASSERT(obj != NULL && obj->type == CX_JSON_NOTHING);
            cxJsonDestroy(&json);
        }
    }
}

CX_TEST(test_json_large_nesting_depth) {
    CxJson json;
    CxJsonValue *d1;
    cxstring text = cx_str("{\"test\": [{},{\"foo\": [[{\"bar\":[4, 2, [null, {\"key\": 47}]]}]]}]}");
    CX_TEST_DO {
        cxJsonInit(&json, NULL);
        cxJsonFill(&json, text);
        cxJsonNext(&json, &d1);

        CX_TEST_ASSERT(d1 != NULL);
        CX_TEST_ASSERT(cxJsonIsObject(d1));
        CxJsonValue *d2 = cxJsonObjGet(d1, "test");
        CX_TEST_ASSERT(cxJsonIsArray(d2));
        CX_TEST_ASSERT(cxJsonArrSize(d2) == 2);
        CxJsonValue *d3 = cxJsonArrGet(d2, 1);
        CX_TEST_ASSERT(cxJsonIsObject(d3));
        CxJsonValue *d4 = cxJsonObjGet(d3, "foo");
        CX_TEST_ASSERT(cxJsonIsArray(d4));
        CX_TEST_ASSERT(cxJsonArrSize(d4) == 1);
        CxJsonValue *d5 = cxJsonArrGet(d4, 0);
        CX_TEST_ASSERT(cxJsonIsArray(d5));
        CX_TEST_ASSERT(cxJsonArrSize(d5) == 1);
        CxJsonValue *d6 = cxJsonArrGet(d5, 0);
        CX_TEST_ASSERT(cxJsonIsObject(d6));
        CxJsonValue *d7 = cxJsonObjGet(d6, "bar");
        CX_TEST_ASSERT(cxJsonIsArray(d7));
        CX_TEST_ASSERT(cxJsonArrSize(d7) == 3);
        CxJsonValue *d8 = cxJsonArrGet(d7, 2);
        CX_TEST_ASSERT(cxJsonIsArray(d8));
        CX_TEST_ASSERT(cxJsonArrSize(d8) == 2);
        CxJsonValue *d9a = cxJsonArrGet(d8, 0);
        CX_TEST_ASSERT(cxJsonIsNull(d9a));
        CxJsonValue *d9b = cxJsonArrGet(d8, 1);
        CX_TEST_ASSERT(cxJsonIsObject(d9b));
        CxJsonValue *d10 = cxJsonObjGet(d9b, "key");
        CX_TEST_ASSERT(cxJsonIsInteger(d10));
        CX_TEST_ASSERT(cxJsonAsInteger(d10) == 47);

        CX_TEST_ASSERT(json.states != json.states_internal);
        CX_TEST_ASSERT(json.states_capacity > cx_nmemb(json.states_internal));
        
        cxJsonValueFree(d1);
        cxJsonDestroy(&json);
    }
}

CX_TEST(test_json_number) {
    CxJson json;
    cxJsonInit(&json, NULL);
    CX_TEST_DO {
        CxJsonValue *v;
        CxJsonStatus result;

        cxJsonFill(&json, "3.1415 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsNumber(v));
        CX_TEST_ASSERT(cxJsonAsDouble(v) == 3.1415);
        cxJsonValueFree(v);

        cxJsonFill(&json, "-47.11e2 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsNumber(v));
        CX_TEST_ASSERT(cxJsonAsDouble(v) == -4711.0);
        cxJsonValueFree(v);

        cxJsonFill(&json, "0.815e-3 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsNumber(v));
        CX_TEST_ASSERT(cxJsonAsDouble(v) == 0.000815);
        cxJsonValueFree(v);

        cxJsonFill(&json, "1.23E4 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsNumber(v));
        CX_TEST_ASSERT(cxJsonAsInteger(v) == 12300);
        CX_TEST_ASSERT(cxJsonAsDouble(v) == 12300.0);
        cxJsonValueFree(v);
    }
    cxJsonDestroy(&json);
}

CX_TEST(test_json_number_format_errors) {
    CxJson json;
    cxJsonInit(&json, NULL);
    CX_TEST_DO {
        CxJsonValue *v;
        CxJsonStatus result;

        cxJsonFill(&json, "+3.1415 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
                        "leading plus is not RFC-8259 compliant");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);

#if 0 // TODO: discuss if it is intended that this produces -47 as valid value
        cxJsonFill(&json, "-47,11e2 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_UNEXPECTED_TOKEN,
                        "decimal separator cannot be a comma");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);
#endif

        cxJsonFill(&json, "0.815e-3.0 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
                        "exponent must be an integer");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);

        cxJsonFill(&json, "3.14e ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
                        "exponent cannot be empty");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);

        cxJsonFill(&json, "3.14e~7 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
                       "exponent cannot start with bullshit");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);

        cxJsonFill(&json, "1.23e4f ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
            "non-digits in exponent");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);

        cxJsonFill(&json, "1.23f ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
            "non-digits in value");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);

        cxJsonFill(&json, "1.23.45 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
            "multiple decimal separators");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);

        cxJsonFill(&json, "184467440737095516150123456789 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
            "30 digit int does not fit into 64-bit int");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);

        cxJsonFill(&json, "18446744073709551615.0123456789 ");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERTM(result == CX_JSON_FORMAT_ERROR_NUMBER,
            "numbers with more than 30 characters are unsupported in general");
        CX_TEST_ASSERT(v->type == CX_JSON_NOTHING);
        cxJsonReset(&json);
    }
    cxJsonDestroy(&json);
}

CX_TEST(test_json_multiple_values) {
    CxJson json;
    cxJsonInit(&json, NULL);
    CX_TEST_DO {
        CxJsonValue *v;
        CxJsonStatus result;
        
        // read number
        cxJsonFill(&json, "10\n");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsNumber(v));
        CX_TEST_ASSERT(cxJsonAsInteger(v) == 10);
        cxJsonValueFree(v);
        // read remaining '\n'
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_INCOMPLETE_DATA);
        // read string
        cxJsonFill(&json, "\"hello world\"\n");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsString(v));
        CX_TEST_ASSERT(!cx_strcmp(cxJsonAsCxString(v), CX_STR("hello world")));
        cxJsonValueFree(v);
        // don't process the remaining newline this time
        // read obj
        cxJsonFill(&json, "{ \"value\": \"test\" }\n");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsObject(v));
        CxJsonValue *value = cxJsonObjGet(v, "value");
        CX_TEST_ASSERT(cxJsonAsString(value));
        cxJsonValueFree(v);
        // read array
        cxJsonFill(&json, "[ 0, 1, 2, 3, 4, 5 ]\n");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsArray(v));
        CxJsonValue *a0 = cxJsonArrGet(v, 0);
        CxJsonValue *a3 = cxJsonArrGet(v, 3);
        CX_TEST_ASSERT(cxJsonIsNumber(a0));
        CX_TEST_ASSERT(cxJsonAsInteger(a0) == 0);
        CX_TEST_ASSERT(cxJsonIsNumber(a3));
        CX_TEST_ASSERT(cxJsonAsInteger(a3) == 3);
        cxJsonValueFree(v);
        // read literal
        cxJsonFill(&json, "true\n");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsLiteral(v));
        CX_TEST_ASSERT(cxJsonIsBool(v));
        CX_TEST_ASSERT(cxJsonIsTrue(v));
        CX_TEST_ASSERT(cxJsonAsBool(v));
        cxJsonValueFree(v);
        cxJsonFill(&json, "false\n");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsLiteral(v));
        CX_TEST_ASSERT(cxJsonIsBool(v));
        CX_TEST_ASSERT(cxJsonIsFalse(v));
        CX_TEST_ASSERT(!cxJsonAsBool(v));
        cxJsonValueFree(v);
        cxJsonFill(&json, "null\n");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsLiteral(v));
        CX_TEST_ASSERT(!cxJsonIsBool(v));
        CX_TEST_ASSERT(cxJsonIsNull(v));
        cxJsonValueFree(v);
    }
    cxJsonDestroy(&json);
}

CX_TEST(test_json_array_iterator) {
    CxJson json;
    cxJsonInit(&json, NULL);
    CX_TEST_DO {
        CxJsonValue *v;
        CxJsonStatus result;
        cxJsonFill(&json, "[ 0, 3, 6, 9, 12, 15 ]\n");
        result = cxJsonNext(&json, &v);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(cxJsonIsArray(v));
        CxIterator iter = cxJsonArrIter(v);
        unsigned i = 0;
        cx_foreach(CxJsonValue*, elem, iter) {
            CX_TEST_ASSERT(cxJsonIsNumber(elem));
            CX_TEST_ASSERT(i == cxJsonAsInteger(elem));
            i += 3;
        }
        cxJsonValueFree(v);
    }
    cxJsonDestroy(&json);
}

CX_TEST(test_json_allocator) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    CxAllocator *allocator = &talloc.base;

    cxstring text = cx_str(
            "{\n"
            "\t\"message\":\"success\",\n"
            "\t\"data\":[\"value1\",{\"x\":123, \"y\":523 }]\n"
            "}"
    );

    CX_TEST_DO {
        CxJson json;
        cxJsonInit(&json, allocator);
        cxJsonFill(&json, text);
        
        CxJsonValue *obj;
        CxJsonStatus result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_NO_ERROR);
        CX_TEST_ASSERT(obj->allocator == allocator);
        
        // this recursively frees everything 
        cxJsonValueFree(obj);
        cxJsonDestroy(&json);

        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
}

CX_TEST(test_json_allocator_parse_error) {
    CxTestingAllocator talloc;
    cx_testing_allocator_init(&talloc);
    CxAllocator *allocator = &talloc.base;

    cxstring text = cx_str(
            "{\n"
            "\t\"message\":\"success\"\n" // <-- missing comma
            "\t\"data\":[\"value1\",{\"x\":123, \"y\":523 }]\n"
            "}"
    );

    CX_TEST_DO {
        CxJson json;
        cxJsonInit(&json, allocator);
        cxJsonFill(&json, text);

        CxJsonValue *obj = NULL;
        CxJsonStatus result = cxJsonNext(&json, &obj);
        CX_TEST_ASSERT(result == CX_JSON_FORMAT_ERROR_UNEXPECTED_TOKEN);
        CX_TEST_ASSERT(obj != NULL && obj->type == CX_JSON_NOTHING);

        // clean-up any left-over memory
        cxJsonDestroy(&json);

        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    }
    cx_testing_allocator_destroy(&talloc);
}

CxTestSuite *cx_test_suite_json(void) {
    CxTestSuite *suite = cx_test_suite_new("json");

    cx_test_register(suite, test_json_init_default);
    cx_test_register(suite, test_json_simple_object);
    cx_test_register(suite, test_json_escaped_strings);
    cx_test_register(suite, test_json_object_incomplete_token);
    cx_test_register(suite, test_json_token_wrongly_completed);
    cx_test_register(suite, test_json_object_error);
    cx_test_register(suite, test_json_subsequent_fill);
    cx_test_register(suite, test_json_large_nesting_depth);
    cx_test_register(suite, test_json_number);
    cx_test_register(suite, test_json_number_format_errors);
    cx_test_register(suite, test_json_multiple_values);
    cx_test_register(suite, test_json_array_iterator);
    cx_test_register(suite, test_json_allocator);
    cx_test_register(suite, test_json_allocator_parse_error);
    
    return suite;
}