/**
 * @copyright   Copyright (c) 2023 Jiawshi
 * @author      Jiawshi (jiawshi@126.com)
 * 
 * @file        test.c
 * @brief       test driven development(test the function in sjson.h whether correct)
 * 
 * @version     V0.01
 * @date        2023-05-17
 * 
 * @note        历史记录: 
 *              - [2023-05-17] [Jiawshi] 创建初始版本
 * @warning     
 * @par         修改记录: 
 * <table>
 * <tr><th>date          <th>Version    <th>Author      <th>Description    </tr>
 * <tr><td>2023-05-17    <td>V0.01      <td>Jiawshi       <td>创建初始版本    </tr>
 * </table>
 */
#include "sjson.h"
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>

static int main_ret = 0;
static int test_count = 0;
static int test_pass = 0;

#define EXPECT_EQ_BASE(equality, expect, actul, format)            \
        do{                     \
            test_count++;       \
            if(equality){       \
                test_pass++;    \
            }                   \
            else{               \
                fprintf(stderr, "[%s]->%d   expect: " format"  " "actual: "  format"\n", __FILE__, __LINE__, expect, actul); \
                main_ret = 1;   \
            }                   \
        }while(0)

#define EXPECT_EQ_INT(expect, actul)        EXPECT_EQ_BASE((expect == actul), expect, actul, "%d")
#define EXPECT_EQ_DOUBLE(expect, actul)     EXPECT_EQ_BASE((expect == actul), expect, actul, "%.17g")
#define EXPECT_EQ_STRING(expect, actul, length)\
            EXPECT_EQ_BASE((sizeof(expect) -1 == length) &&(memcmp(expect, actul, length) == 0), expect, actul, "%s")

// #define EXPECT_TRUE(actul)                  EXPECT_EQ_BASE(1 == actul, 1, actul, "%d")
// #define EXPECT_FALSE(actul)                 EXPECT_EQ_BASE(0 == actul, 0, actul, "%d")


#define EXPECT_TRUE(actual) EXPECT_EQ_BASE((actual) != 0, "true", "false", "%s")
#define EXPECT_FALSE(actual) EXPECT_EQ_BASE((actual) == 0, "false", "true", "%s")

#define EXPECT_EQ_SIZE_T(expect, actual)    EXPECT_EQ_BASE((expect == actual), (size_t)expect, (size_t)actual, "%zu")

//#define EXPECT_EQ_BOOLEAN(expect, actul)\
//          EXPECT_EQ_BASE(expect == actul, expect, actul, )

/* this func test number*/
#define TEST_NUMBER(expect, actul)   \
        do{\
            s_value value;\
            value.type = S_NULL;\
            EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, actul));\
            EXPECT_EQ_INT(S_NUMBER, s_get_type(&value));\
            EXPECT_EQ_INT(expect, s_get_number(&value));\
        }while(0)


#define TEST_ERROR(error, actul)\
        do{\
            s_value value;\
            value.type = S_NULL;\
            EXPECT_EQ_INT(error, s_parse(&value, actul));\
            EXPECT_EQ_INT(S_NULL, s_get_type(&value));\
        }while(0)


#define TEST_ERROR_VALUE(error_mode, invalid_value) \
        do {\
            s_value value;\
            value.type = S_NULL;\
            EXPECT_EQ_INT(error_mode, s_parse(&value, invalid_value));\
            EXPECT_EQ_INT(S_NULL, s_get_type(&value));\
        }while(0)


#define TEST_STRING(expect, actul)\
        do {\
            s_value value;\
            value.type = S_NULL;\
            EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, actul));\
            EXPECT_EQ_INT(S_STRING, s_get_type(&value));\
            EXPECT_EQ_STRING(expect, s_parse_get_string(&value), s_parse_get_string_length(&value));\
            s_parse_value_free(&value);\
        } while(0)


#define TEST_ROUNDTRIP(json)\
        do {\
            s_value value;\
            char *json1;\
            size_t len;\
            EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, json));\
            json1 = s_parse_value_stringify(&value, &len);\
            EXPECT_EQ_STRING(json, json1, len);\
            s_parse_value_free(&value);\
            free(json1);\
        } while(0)

static void test_parse_null(void)
{
    s_value value;
    value.type = S_TRUE;

    EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, "null"));
    EXPECT_EQ_INT(S_NULL, s_get_type(&value));
}

static void test_parse_true(void)
{
    s_value value;
    value.type = S_TRUE;
    EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, "true"));
    EXPECT_EQ_INT(S_TRUE, s_get_type(&value));
}

static void test_access_string(void){
    s_value value;
    s_parse_value_init(&value);
    //value.data.string.s = "";
    //value.data.string.str_len = 0;
    //value.type = S_NULL;
    s_parse_set_string(&value, "", 0);
    EXPECT_EQ_STRING("", s_parse_get_string, s_parse_get_string_length(&value));
    s_parse_set_string(&value, "hello", 5);
    EXPECT_EQ_STRING("", s_parse_get_string(&value), 0);

    s_parse_value_free(&value);
    //EXPECT_EQ_STRING("\"");
}


static void test_access_bool(void)
{
    s_value value;
    s_parse_value_init(&value);
    s_parse_set_boolean(&value, 1);
    EXPECT_TRUE(s_parse_get_boolean(&value));
    
    s_parse_set_boolean(&value, 0);
    EXPECT_FALSE(s_parse_get_boolean(&value));
    s_parse_value_free(&value);
}


static void test_access_number(void)
{
    s_value value;
    s_parse_value_init(&value);
    s_parse_set_number(&value, 3);
    EXPECT_EQ_DOUBLE(3, s_get_number(&value));
    s_parse_set_number(&value, 1.234);
    EXPECT_EQ_DOUBLE(1.234, s_get_number(&value));
    s_parse_value_free(&value);

}

static void test_parse_false(void)
{
    s_value value;
    value.type = S_TRUE;
    EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, "false"));
    EXPECT_EQ_INT(S_FALSE, s_get_type(&value));
}

static void test_parse_section_err(void)
{
    s_value value;
    value.type = S_TRUE;
    EXPECT_EQ_INT(S_PARSE_VALUE_ERR, s_parse(&value, "null x"));
    EXPECT_EQ_INT(S_NULL, s_get_type(&value));
}

static void test_access_null(void)
{
    s_value value;
    s_parse_value_init(&value);
    s_parse_set_number(&value, 2);
    s_parse_set_null(&value);
    EXPECT_EQ_INT(S_NULL, s_get_type(&value));

    s_parse_set_string(&value, "hh", 2);
    s_parse_set_null(&value);
    EXPECT_EQ_INT(S_NULL, s_get_type(&value));
    s_parse_value_free(&value);
}

static void test_parse_expect_value(void)
{
#if 1
    s_value value;
    value.type = S_TRUE;
    EXPECT_EQ_INT(S_PARSE_EXPECT_VALUE, s_parse(&value, ""));
    EXPECT_EQ_INT(S_NULL, s_get_type(&value));
#endif

    TEST_ERROR_VALUE(S_PARSE_EXPECT_VALUE, "");
}



static void test_parse_invalid_value(void)
{
#if 0
    s_value value;
    value.type = S_TRUE;
    EXPECT_EQ_INT(S_PARSE_INVALID_VALUE, s_parse(&value, "i"));
    EXPECT_EQ_INT(S_NULL, s_get_type(&value));
#endif
    TEST_ERROR_VALUE(S_PARSE_INVALID_VALUE, "i");
    TEST_ERROR_VALUE(S_PARSE_INVALID_VALUE, "?");

    TEST_ERROR_VALUE(S_PARSE_VALUE_ERR, "0123"); /* after zero should be '.' or nothing */
    TEST_ERROR_VALUE(S_PARSE_VALUE_ERR, "0x0");
    TEST_ERROR(S_PARSE_VALUE_ERR, "0x123");
}

static void test_number(void)
{
    TEST_NUMBER(0.0, "0");
    TEST_NUMBER(0.0, "-0");
    TEST_NUMBER(0.0, "-0.0");
    TEST_NUMBER(1.0, "1");
    TEST_NUMBER(-1.0, "-1");
    TEST_NUMBER(1.5, "1.5");
    TEST_NUMBER(-1.5, "-1.5");
    TEST_NUMBER(3.1416, "3.1416");
    TEST_NUMBER(1E10, "1E10");
    TEST_NUMBER(1e10, "1e10");
    TEST_NUMBER(1E+10, "1E+10");
    TEST_NUMBER(1E-10, "1E-10");
    TEST_NUMBER(-1E10, "-1E10");
    TEST_NUMBER(-1e10, "-1e10");
    TEST_NUMBER(-1E+10, "-1E+10");
    TEST_NUMBER(-1E-10, "-1E-10");
    TEST_NUMBER(1.234E+10, "1.234E+10");
    TEST_NUMBER(1.234E-10, "1.234E-10");
    TEST_NUMBER(0.0, "1e-10000"); 


    TEST_NUMBER(1.0000000000000002, "1.0000000000000002"); /* the smallest number > 1 */
    TEST_NUMBER( 4.9406564584124654e-324, "4.9406564584124654e-324"); /* minimum denormal */
    TEST_NUMBER(-4.9406564584124654e-324, "-4.9406564584124654e-324");
    TEST_NUMBER( 2.2250738585072009e-308, "2.2250738585072009e-308");  /* Max subnormal double */
    TEST_NUMBER(-2.2250738585072009e-308, "-2.2250738585072009e-308");
    TEST_NUMBER( 2.2250738585072014e-308, "2.2250738585072014e-308");  /* Min normal positive double */
    TEST_NUMBER(-2.2250738585072014e-308, "-2.2250738585072014e-308");
    TEST_NUMBER( 1.7976931348623157e+308, "1.7976931348623157e+308");  /* Max double */
    TEST_NUMBER(-1.7976931348623157e+308, "-1.7976931348623157e+308");
}


static void test_parse_number_invalid_value(void)
{
    
    
    TEST_ERROR(S_PARSE_INVALID_VALUE, "nul");
    TEST_ERROR(S_PARSE_INVALID_VALUE, "?");
    
    TEST_ERROR(S_PARSE_INVALID_VALUE, "+0");
    TEST_ERROR(S_PARSE_INVALID_VALUE, "+1");
    TEST_ERROR(S_PARSE_INVALID_VALUE, ".123"); /* at least one digit before '.' */
    TEST_ERROR(S_PARSE_INVALID_VALUE, "1.");   /* at least one digit after '.' */
    TEST_ERROR(S_PARSE_INVALID_VALUE, "INF");
    TEST_ERROR(S_PARSE_INVALID_VALUE, "inf");
    TEST_ERROR(S_PARSE_INVALID_VALUE, "NAN");
    TEST_ERROR(S_PARSE_INVALID_VALUE, "nan");

    TEST_ERROR(S_PARSE_INVALID_VALUE, "[1,]");
    TEST_ERROR(S_PARSE_INVALID_VALUE, "[\"a\", nul]");

}

static void test_parse_number_too_big() {
    TEST_ERROR(S_PARSE_NUMBER_TOOBIG, "1e309");
    TEST_ERROR(S_PARSE_NUMBER_TOOBIG, "-1e309");
}


static void test_parse_string(void)
{
    TEST_STRING("", "\"\"");
    TEST_STRING("Hello", "\"Hello\"");
    TEST_STRING("Hello\nWorld", "\"Hello\\nWorld\"");
    TEST_STRING("\" \\ / \b \f \n \r \t", "\"\\\" \\\\ \\/ \\b \\f \\n \\r \\t\"");
    TEST_STRING("Hello\0World", "\"Hello\\u0000World\"");
    TEST_STRING("\x24", "\"\\u0024\"");         /* Dollar sign U+0024 */
    TEST_STRING("\xC2\xA2", "\"\\u00A2\"");     /* Cents sign U+00A2 */
    TEST_STRING("\xE2\x82\xAC", "\"\\u20AC\""); /* Euro sign U+20AC */
    TEST_STRING("\xF0\x9D\x84\x9E", "\"\\uD834\\uDD1E\"");  /* G clef sign U+1D11E */
    TEST_STRING("\xF0\x9D\x84\x9E", "\"\\ud834\\udd1e\"");  /* G clef sign U+1D11E */

}

static void test_parse_string_miss_quotation(void)
{
    TEST_ERROR(S_PARSE_STRING_MISS_QUOTATION, "\"");
    TEST_ERROR(S_PARSE_STRING_MISS_QUOTATION, "\"abc");
}

static void test_parse_string_value_invalid(void)
{
    TEST_ERROR(S_PARSE_STRING_INVALID_VALUE, "\"\\v\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_VALUE, "\"\\'\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_VALUE, "\"\\0\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_VALUE, "\"\\x12\"");




}


static void test_parse_string_unicode_invalid_surrogate(void)
{
    TEST_ERROR(S_PARSE_STRING_UNICODE_INVALID_SURROGATE, "\"\\uD800\"");
    TEST_ERROR(S_PARSE_STRING_UNICODE_INVALID_SURROGATE, "\"\\uDBFF\"");
    TEST_ERROR(S_PARSE_STRING_UNICODE_INVALID_SURROGATE, "\"\\uD800\\\\\"");
    TEST_ERROR(S_PARSE_STRING_UNICODE_INVALID_SURROGATE, "\"\\uD800\\uDBFF\"");
    TEST_ERROR(S_PARSE_STRING_UNICODE_INVALID_SURROGATE, "\"\\uD800\\uE000\"");
}

static void test_parse_string_invalid_hex(void)
{
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u0\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u01\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u012\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u/000\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\uG000\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u0/00\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u0G00\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u00/0\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u00G0\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u000/\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u000G\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_UNICODE_HEX, "\"\\u 123\"");
}

static void test_parse_string_char_invalid(void)
{
    TEST_ERROR(S_PARSE_STRING_INVALID_CHAR, "\"\x01\"");
    TEST_ERROR(S_PARSE_STRING_INVALID_CHAR, "\"\x1F\"");
}


static void test_parse_invalid_array(void)
{
#if 1
    TEST_ERROR(S_PARSE_ARR_ERR, "[1");
    TEST_ERROR(S_PARSE_ARR_ERR, "[1}");
    TEST_ERROR(S_PARSE_ARR_ERR, "[1 2");
    TEST_ERROR(S_PARSE_ARR_ERR, "[[]");
    TEST_ERROR(S_PARSE_INVALID_VALUE, "[1,]");
    TEST_ERROR(S_PARSE_INVALID_VALUE, "[\"a\", nul]");
#endif

}


static void test_access_number_1(void)
{
    s_value value;
    s_parse_value_init(&value);
    s_parse_set_string(&value, "a", 1);
    s_parse_value_free(&value);
    s_set_number(&value, 1234.5);

    EXPECT_EQ_DOUBLE(1234.5, s_get_number(&value));
    s_parse_value_free(&value);
}

static void test_access_array(void)
{
    s_value value;
    s_parse_value_init(&value);

    
    EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, "[null,false,true,123,\"abc\"]"));
    EXPECT_EQ_INT(5, s_parse_get_array_size(&value));
    EXPECT_EQ_INT(S_ARRAY, s_get_type(&value));
    EXPECT_EQ_INT(S_NULL, s_get_type(s_parse_get_array_element(&value, 0)));
    EXPECT_EQ_INT(S_FALSE, s_get_type(s_parse_get_array_element(&value, 1)));
    EXPECT_EQ_INT(S_TRUE, s_get_type(s_parse_get_array_element(&value, 2)));
    EXPECT_EQ_INT(S_NUMBER, s_get_type(s_parse_get_array_element(&value, 3)));
    EXPECT_EQ_INT(S_STRING, s_get_type(s_parse_get_array_element(&value, 4)));

    EXPECT_EQ_DOUBLE(123.0, s_get_number(s_parse_get_array_element(&value, 3)));
    EXPECT_EQ_STRING("abc", s_parse_get_string(s_parse_get_array_element(&value, 4)), s_parse_get_string_length(s_parse_get_array_element(&value, 4)));
    s_parse_value_free(&value);

    s_parse_value_init(&value);
    EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, "[ [ ] , [0 ], [ 0 ,1], [0,1,2] ]"));
    EXPECT_EQ_INT(4, s_parse_get_array_size(&value));
    EXPECT_EQ_INT(S_ARRAY, s_get_type(&value));
    
    int i, j;
   
    for (i = 0; i < 4; i++) {
        const s_value *value1;
        value1 = s_parse_get_array_element(&value, i);
        EXPECT_EQ_INT(S_ARRAY, s_get_type(value1));
        EXPECT_EQ_INT(i, s_parse_get_array_size(value1));

        
        for (j = 0; j < i; j++) {
            const s_value *value2;
            value2 = s_parse_get_array_element(value1, j);
            EXPECT_EQ_INT(S_NUMBER, s_get_type(value2));
            EXPECT_EQ_DOUBLE((double)j, s_get_number(value2));
        }
  
    }

    s_parse_value_free(&value);
}



static void test_new_array(void)
{
    s_value value, v;
    int i, j;

    s_parse_value_init(&value);
    for (j = 0; j <= 5; j += 5) {
        s_set_value_array(&value, j);
        EXPECT_EQ_SIZE_T(0, s_parse_get_array_size(&value));
        EXPECT_EQ_SIZE_T(j, s_get_array_capacity(&value));

        for (i = 0; i < 10; i++) {
            s_parse_value_init(&v);
            s_set_number(&v, i);
            s_value_move(s_value_push_array_element(&value), &v);
            s_parse_value_free(&v);
        }


        EXPECT_EQ_SIZE_T(10, s_parse_get_array_size(&value));

        for (i = 0; i < 10; i++) {
            EXPECT_EQ_DOUBLE((double)i, s_get_number(s_parse_get_array_element(&value, i)));
        }
        // if not free ,it will bring memory leak
        if (j == 0) {
            s_parse_value_free(&value);
        }
    }


    s_value_pop_array_element(&value);
    EXPECT_EQ_SIZE_T(9, s_parse_get_array_size(&value));
    for (i = 0; i < 9; i++) {
        EXPECT_EQ_DOUBLE((double)i, s_get_number(s_parse_get_array_element(&value, i)));
    }

    s_value_earse_array_element(&value, 4, 0);
    EXPECT_EQ_SIZE_T(9, s_parse_get_array_size(&value));
    for (i = 0; i < 9; i++) {
        EXPECT_EQ_DOUBLE((double)i, s_get_number(s_parse_get_array_element(&value, i)));
    }

    s_value_earse_array_element(&value, 8, 1);
    EXPECT_EQ_SIZE_T(8, s_parse_get_array_size(&value));
    for (i = 0; i < 8; i++) {
        EXPECT_EQ_DOUBLE((double)i, s_get_number(s_parse_get_array_element(&value, i)));
    }

    s_value_earse_array_element(&value, 0, 2);
    EXPECT_EQ_SIZE_T(6, s_parse_get_array_size(&value));
    for (i = 0; i < 6; i++) {
        EXPECT_EQ_DOUBLE((double)(i + 2), s_get_number(s_parse_get_array_element(&value, i)));
    }
 
#if 1
    for (i = 0; i < 2; i++) {
        s_parse_value_init(&v);
        s_parse_set_number(&v, i);

        s_value_move(s_value_insert_array_element(&value, i), &v);
        s_parse_value_free(&v);
        
    }
#endif

    EXPECT_EQ_SIZE_T(8, s_parse_get_array_size(&value));
    for (i = 0; i < 8; i++) {
        EXPECT_EQ_DOUBLE((double)i, s_get_number(s_parse_get_array_element(&value, i)));
    }

    EXPECT_TRUE(s_get_array_capacity(&value) > 8);

    s_value_shrink_array_capacity(&value);
    
    EXPECT_EQ_SIZE_T(8, s_get_array_capacity(&value));
    EXPECT_EQ_SIZE_T(8, s_parse_get_array_size(&value));
    for (i = 0; i < 8; i++) {
        EXPECT_EQ_DOUBLE((double)i, s_get_number(s_parse_get_array_element(&value, i)));
    }


    s_parse_set_string(&v, "hello", 5);
    s_value_move(s_value_push_array_element(&value), &v);
    s_parse_value_free(&v);

    i = s_get_array_capacity(&value);
    s_value_clear_array(&value);

    EXPECT_EQ_SIZE_T(0, s_parse_get_array_size(&value));
    EXPECT_EQ_SIZE_T(i, s_get_array_capacity(&value));

    s_value_shrink_array_capacity(&value);
    EXPECT_EQ_SIZE_T(0, s_get_array_capacity(&value));

    s_parse_value_free(&value);

}



static void test_new_object(void)
{
    size_t i, j, index;
    s_value value, v;
    s_value *pc;
    s_parse_value_init(&value);


    for (j = 0; j <= 5; j += 5) {
        s_value_set_object(&value, j);
        //PRT("%d", s_value_get_member_capacity(&value));

        EXPECT_EQ_SIZE_T(0, s_parse_get_object_size(&value));
        EXPECT_EQ_SIZE_T(j, s_value_get_member_capacity(&value));

        for (i = 0; i < 10; i++) {
            s_parse_value_init(&v);
            char k[2] = "a";
            k[0] += i;
            s_set_number(&v, i);
            //PRT("%s", k);
            s_value_move(s_set_member_value(&value, k, 1), &v);
            s_parse_value_free(&v);
        }

        //PRT("%d", s_value_get_member_capacity(&value));

        for (i = 0; i < 10; i++) {
            char key[2] = "a";
            key[0] += i;
            size_t index;
            index = s_find_value_member_index(&value, key, 1);
            //PRT("jjjjjjjjjjjjjjj%d", index);
            EXPECT_TRUE(index != KEY_NOT_EXIST);
            pc = s_parse_get_member(&value, index);
            //PRT("%f", s_get_number(pc));
            EXPECT_EQ_DOUBLE((double)i, s_get_number(pc));


        }
    }

  

    index = s_find_value_member_index(&value, "j", 1);
    EXPECT_TRUE(index != KEY_NOT_EXIST);
    s_remove_member_value(&value, index);

    index = s_find_value_member_index(&value, "j", 1);
    EXPECT_TRUE(index == KEY_NOT_EXIST);
    EXPECT_EQ_SIZE_T(9, s_parse_get_object_size(&value));


    index = s_find_value_member_index(&value, "a", 1);
    EXPECT_TRUE(index != KEY_NOT_EXIST);
    s_remove_member_value(&value, index);

    index = s_find_value_member_index(&value, "a", 1);
    EXPECT_TRUE(index == KEY_NOT_EXIST);
    EXPECT_EQ_SIZE_T(8, s_parse_get_object_size(&value));

    for (i = 0; i < 8; i++) {
        char key[2] = "a";
        key[0] += i + 1;
        size_t index;
        index = s_find_value_member_index(&value, key, 1);
        //PRT("============%d", index);
        EXPECT_TRUE(index != KEY_NOT_EXIST);
        pc = s_parse_get_member(&value, index);
        //PRT("%f", s_get_number(pc));
        EXPECT_EQ_DOUBLE((double)i +1, s_get_number(pc));


    }

    EXPECT_TRUE(s_value_get_member_capacity(&value) > 8);
    s_value_shrink_member_capacity(&value);


    EXPECT_EQ_SIZE_T(8, s_parse_get_object_size(&value));
    EXPECT_EQ_SIZE_T(8, s_value_get_member_capacity(&value));
    //PRT();

    for (i = 0; i < 8; i++) {
        char key[2] = "a";
        key[0] += (i + 1);

        EXPECT_EQ_DOUBLE((double)(i +1), s_get_number(s_parse_get_member(&value, s_find_value_member_index(&value, key, 1))));
        
    }

    s_parse_set_string(&v, "hello", 5);
    s_value_move(s_set_member_value(&value, "world", 5), &v);
    s_parse_value_free(&v);

    pc = s_find_value_member_value(&value, "world", 5);
    EXPECT_TRUE(pc != NULL);
    EXPECT_EQ_STRING("hello", s_parse_get_string(pc), s_parse_get_string_length(pc));



    i = s_value_get_member_capacity(&value);
    s_value_clear_member(&value);
    EXPECT_EQ_INT(0, s_parse_get_object_size(&value));
    EXPECT_EQ_SIZE_T(i, s_value_get_member_capacity(&value));

    s_value_shrink_member_capacity(&value);
    EXPECT_EQ_SIZE_T(0, s_value_get_member_capacity(&value));
    s_parse_value_free(&value);




}



static void test_parse_object(void)
{
    s_value value;
    s_parse_value_init(&value);

    EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value, " { } "));
    EXPECT_EQ_INT(S_OBJIECT, s_get_type(&value));
    EXPECT_EQ_INT(0, s_parse_get_object_size(&value));

    s_parse_value_free(&value);
    s_parse_value_init(&value);

    EXPECT_EQ_INT(S_PARSE_OK, s_parse(&value,
        " { "
        "\"n\" : null , "
        "\"f\" : false , "
        "\"t\" : true , "
        "\"i\" : 123 , "
        "\"s\" : \"abc\", "
        "\"a\" : [ 1, 2, 3 ],"
        "\"o\" : { \"1\" : 1, \"2\" : 2, \"3\" : 3 }"
        " } "
    ));

    EXPECT_EQ_INT(S_OBJIECT, s_get_type(&value));
    EXPECT_EQ_INT(7, s_parse_get_object_size(&value));

    EXPECT_EQ_STRING("n", s_parse_get_member_key(&value, 0), s_parse_get_key_length(&value, 0));
    EXPECT_EQ_INT(S_NULL, s_get_type(s_parse_get_member_value(&value, 0)));

    EXPECT_EQ_STRING("f", s_parse_get_member_key(&value, 1), s_parse_get_key_length(&value, 1));
    EXPECT_EQ_INT(S_FALSE, s_get_type(s_parse_get_member_value(&value, 1)));

    EXPECT_EQ_STRING("t", s_parse_get_member_key(&value, 2), s_parse_get_key_length(&value, 2));
    EXPECT_EQ_INT(S_TRUE, s_get_type(s_parse_get_member_value(&value, 2)));

    EXPECT_EQ_STRING("i", s_parse_get_member_key(&value, 3), s_parse_get_key_length(&value, 3));
    EXPECT_EQ_INT(S_NUMBER, s_get_type(s_parse_get_member_value(&value, 3)));
    EXPECT_EQ_DOUBLE(123.0, s_get_number(s_parse_get_member_value(&value, 3)));

    EXPECT_EQ_STRING("s", s_parse_get_member_key(&value, 4), s_parse_get_key_length(&value, 4));
    EXPECT_EQ_INT(S_STRING, s_get_type(s_parse_get_member_value(&value, 4)));
    EXPECT_EQ_STRING("abc", s_parse_get_string(s_parse_get_member_value(&value, 4)), s_parse_get_string_length(s_parse_get_member_value(&value, 4)));

    EXPECT_EQ_STRING("a", s_parse_get_member_key(&value, 5), s_parse_get_key_length(&value, 5));
    EXPECT_EQ_INT(S_ARRAY, s_get_type(s_parse_get_member_value(&value, 5)));
    EXPECT_EQ_INT(3, s_parse_get_array_size(s_parse_get_member_value(&value, 5)));

    int i;
    for (i = 0; i < 3; i++) {
        const s_value *value1 = s_parse_get_array_element(s_parse_get_member_value(&value, 5), i);

        EXPECT_EQ_INT(S_NUMBER, s_get_type(value1));
        EXPECT_EQ_DOUBLE(i + 1.0, s_get_number(value1));

    }

    EXPECT_EQ_STRING("o", s_parse_get_member_key(&value, 6), s_parse_get_key_length(&value, 6));
    EXPECT_EQ_INT(S_OBJIECT, s_get_type(s_parse_get_member_value(&value, 6)));
    const s_value *value2 = s_parse_get_member_value(&value, 6);

    for (i = 0; i < 3; i++) {
        const s_value *value3 = s_parse_get_member_value(value2, i);
        
        EXPECT_TRUE('1' + i ==(s_parse_get_member_key(value2, i))[0]);
        //PRT("%c", s_parse_get_member_key(value2, i)[0]);

        EXPECT_EQ_INT(1, s_parse_get_key_length(value2, i));
        EXPECT_EQ_INT(S_NUMBER, s_get_type(value3));
        EXPECT_EQ_DOUBLE(i + 1.0, s_get_number(value3));
    }
    
    s_parse_value_free(&value);

}

static void test_parse_miss_colon(void)
{
    TEST_ERROR(S_PARSE_OBJECT_MISS_COLON, "{\"a\"}");
    TEST_ERROR(S_PARSE_OBJECT_MISS_COLON, "{\"a\",\"b\"}");
}

static void test_parse_object_err(void)
{
    TEST_ERROR(S_PARSE_OBJECT_ERR, "{\"a\":1");
    TEST_ERROR(S_PARSE_OBJECT_ERR, "{\"a\":1]");
    TEST_ERROR(S_PARSE_OBJECT_ERR, "{\"a\":1 \"b\"");
    TEST_ERROR(S_PARSE_OBJECT_ERR, "{\"a\":{}");
}

static void test_parse_miss_key(void)
{
    TEST_ERROR(S_PARSE_OBJECT_MISS_KEY, "{:1,");
    TEST_ERROR(S_PARSE_OBJECT_MISS_KEY, "{1:1,");
    TEST_ERROR(S_PARSE_OBJECT_MISS_KEY, "{true:1,");
    TEST_ERROR(S_PARSE_OBJECT_MISS_KEY, "{false:1,");
    TEST_ERROR(S_PARSE_OBJECT_MISS_KEY, "{null:1,");
    TEST_ERROR(S_PARSE_OBJECT_MISS_KEY, "{[]:1,");
    TEST_ERROR(S_PARSE_OBJECT_MISS_KEY, "{{}:1,");
    TEST_ERROR(S_PARSE_OBJECT_MISS_KEY, "{\"a\":1,");
}

static void test_stringify_string(void)
{
    TEST_ROUNDTRIP("\"\"");
    TEST_ROUNDTRIP("\"Hello\"");
    TEST_ROUNDTRIP("\"Hello\\nWorld\"");
    TEST_ROUNDTRIP("\"\\\" \\\\ / \\b \\f \\n \\r \\t\"");
    TEST_ROUNDTRIP("\"Hello\\u0000World\"");
}

static void test_stringify_array(void)
{
    TEST_ROUNDTRIP("[]");
    TEST_ROUNDTRIP("[null,false,true,123,\"abc\",[1,2,3]]");
}



static void test_stringify_member(void)
{
    TEST_ROUNDTRIP("{}");
    TEST_ROUNDTRIP("{\"n\":null,\"f\":false,\"t\":true,\"i\":123,\"s\":\"abc\",\"a\":[1,2,3],\"o\":{\"1\":1,\"2\":2,\"3\":3}}");
}

static void test_stringify_number(void)
{
    TEST_ROUNDTRIP("0");
    TEST_ROUNDTRIP("-0");
    TEST_ROUNDTRIP("1");
    TEST_ROUNDTRIP("-1");
    TEST_ROUNDTRIP("1.5");
    TEST_ROUNDTRIP("-1.5");
    TEST_ROUNDTRIP("3.25");
    TEST_ROUNDTRIP("1e+20");
    TEST_ROUNDTRIP("1.234e+20");
    TEST_ROUNDTRIP("1.234e-20");

    TEST_ROUNDTRIP("1.0000000000000002"); /* the smallest number > 1 */
    TEST_ROUNDTRIP("4.9406564584124654e-324"); /* minimum denormal */
    TEST_ROUNDTRIP("-4.9406564584124654e-324");
    TEST_ROUNDTRIP("2.2250738585072009e-308");  /* Max subnormal double */
    TEST_ROUNDTRIP("-2.2250738585072009e-308");
    TEST_ROUNDTRIP("2.2250738585072014e-308");  /* Min normal positive double */
    TEST_ROUNDTRIP("-2.2250738585072014e-308");
    TEST_ROUNDTRIP("1.7976931348623157e+308");  /* Max double */
    TEST_ROUNDTRIP("-1.7976931348623157e+308");
}

static void test_stringify(void)
{
    TEST_ROUNDTRIP("null");
    TEST_ROUNDTRIP("false");
    TEST_ROUNDTRIP("true");
    test_stringify_array();
    test_stringify_number();
    test_stringify_member();
    test_stringify_string();

}


static void test_swap(void)
{
    s_value v1, v2;
    s_parse_value_init(&v1);
    s_parse_value_init(&v2);

    s_parse_set_string(&v1, "hello", 5);
    s_parse_set_string(&v2, "world!", 6);
    s_value_swap(&v1, &v2);

    EXPECT_EQ_STRING("world!", s_parse_get_string(&v1), s_parse_get_string_length(&v1));
    EXPECT_EQ_STRING("hello", s_parse_get_string(&v2), s_parse_get_string_length(&v2));

    s_parse_value_free(&v1);
    s_parse_value_free(&v2);
}

   
static void test_move(void)
{
    s_value v1, v2, v3;
    s_parse_value_init(&v1);
    s_parse_value_init(&v2);
    s_parse_value_init(&v3);


    s_parse(&v1, "{\"t\":true,\"f\":false,\"n\":null,\"d\":1.5,\"a\":[1,2,3]}");
    PRT("%d", s_get_type(&v1));

    s_value_copy(&v2, &v1);
    s_value_move(&v3, &v2);

    EXPECT_EQ_INT(S_NULL, s_get_type(&v2));
    EXPECT_TRUE(s_value_is_equal(&v1, &v3));
    s_parse_value_free(&v1);
    s_parse_value_free(&v2);
    s_parse_value_free(&v3);


}

static void test_copy(void)
{
    s_value v1, v2;
    s_parse_value_init(&v1);
    s_parse_value_init(&v2);

    s_parse(&v1, "{\"t\":true,\"f\":false,\"n\":null,\"d\":1.5,\"a\":[1,2,3]}");
    s_value_copy(&v2, &v1);

    EXPECT_TRUE(s_value_is_equal(&v1, &v2));
    s_parse_value_free(&v1);
    s_parse_value_free(&v2);
}


#define TEST_EQUAL(json1, json2, equality) \
        do {\
            s_value v1, v2;\
            s_parse_value_init(&v1);\
            s_parse_value_init(&v2);\
            EXPECT_EQ_INT(S_PARSE_OK, s_parse(&v1, json1));\
            EXPECT_EQ_INT(S_PARSE_OK, s_parse(&v2, json2));\
            EXPECT_EQ_INT(equality, s_value_is_equal(&v1, &v2));\
            s_parse_value_free(&v1);\
            s_parse_value_free(&v2);\
        } while (0)



static void test_equal(void)
{
    TEST_EQUAL("true", "true", 1);
    TEST_EQUAL("true", "false", 0);
    TEST_EQUAL("false", "false", 1);
    TEST_EQUAL("null", "null", 1);
    TEST_EQUAL("null", "0", 0);
    TEST_EQUAL("123", "123", 1);
    TEST_EQUAL("123", "456", 0);
    TEST_EQUAL("\"abc\"", "\"abc\"", 1);
    TEST_EQUAL("\"abc\"", "\"abcd\"", 0);
    TEST_EQUAL("[]", "[]", 1);
    TEST_EQUAL("[]", "null", 0);
    TEST_EQUAL("[1,2,3]", "[1,2,3]", 1);
    TEST_EQUAL("[1,2,3]", "[1,2,3,4]", 0);
    TEST_EQUAL("[[]]", "[[]]", 1);
    TEST_EQUAL("{}", "{}", 1);
    TEST_EQUAL("{}", "null", 0);
    TEST_EQUAL("{}", "[]", 0);
    TEST_EQUAL("{\"a\":1,\"b\":2}", "{\"a\":1,\"b\":2}", 1);
    
    TEST_EQUAL("{\"a\":1,\"b\":2}", "{\"b\":2,\"a\":1}", 1);
    
    TEST_EQUAL("{\"a\":1,\"b\":2}", "{\"a\":1,\"b\":3}", 0);
    TEST_EQUAL("{\"a\":1,\"b\":2}", "{\"a\":1,\"b\":2,\"c\":3}", 0);
    TEST_EQUAL("{\"a\":{\"b\":{\"c\":{}}}}", "{\"a\":{\"b\":{\"c\":{}}}}", 1);
    TEST_EQUAL("{\"a\":{\"b\":{\"c\":{}}}}", "{\"a\":{\"b\":{\"c\":[]}}}", 0);
}

static void test_parse(void)
{
    test_parse_null();
    test_parse_false();
    test_parse_true();
    test_parse_section_err();
    test_parse_expect_value();
    test_parse_invalid_value();

    test_number();
    test_parse_number_invalid_value();
    
    test_parse_number_too_big();

    test_parse_string();
    
    test_access_string();
    test_access_number();
    test_access_bool();
    test_access_null();
    test_parse_string_miss_quotation();
    test_parse_string_value_invalid();
    test_parse_string_char_invalid();
    test_parse_string_unicode_invalid_surrogate();
    test_parse_string_invalid_hex();
    test_parse_invalid_array();
    test_access_array();
    test_parse_object();
    test_parse_miss_colon();
    test_parse_object_err();
    test_parse_miss_key();
    test_stringify();
    test_new_array();
    test_new_object();
    test_access_number_1();
    test_swap();
    test_move();
    test_copy();
    test_equal();


}




int main()
{
    test_parse();
    printf("%d/%d   < %3.2f%%> passed\n", test_pass, test_count, test_pass * 100.0/ test_count);
    return 0;
}