/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include "gtest/gtest.h"

extern "C" {
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include <ffi.h>

#include "dyn_type_common.h"
#include "dyn_common.h"
#include "dyn_type.h"
#include "json_serializer.h"

static void stdLog(void*, int level, const char *file, int line, const char *msg, ...) {
	va_list ap;
	const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
	fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
	va_start(ap, msg);
	vfprintf(stderr, msg, ap);
	fprintf(stderr, "\n");
	va_end(ap);
}

/*********** example 1 ************************/
/** struct type ******************************/
const char *example1_descriptor = "{DJISF a b c d e}";

static const char *avpr_example1_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Double\", \
                    \"size\" : 8, \
                    \"alias\" : \"double\" \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Slong\", \
                    \"size\" : 8, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Sint\", \
                    \"size\" : 4, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Short\", \
                    \"size\" : 2, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Float\", \
                    \"size\" : 4, \
                    \"alias\" : \"float\" \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structA\", \
                    \"fields\" : [{\
                        \"name\" : \"a\", \
                        \"type\" : \"Double\" \
                    }, {\
                        \"name\" : \"b\", \
                        \"type\" : \"Slong\" \
                    }, {\
                        \"name\" : \"c\", \
                        \"type\" : \"Sint\" \
                    }, {\
                        \"name\" : \"d\", \
                        \"type\" : \"Short\" \
                    }, {\
                        \"name\" : \"e\", \
                        \"type\" : \"Float\" \
                    }]\
                }], \
                \"messages\" : {} \
            }";

static const char *avpr_example1_fqn = "test.ns.structA";

const char *example1_input = "{ \
    \"a\" : 1.0, \
    \"b\" : 22, \
    \"c\" : 32, \
    \"d\" : 42, \
    \"e\" : 4.4 \
}";

struct example1 {
	double a;   //0
	int64_t b;  //1
	int32_t c;  //2
	int16_t d;  //3
	float e;    //4
};

static void check_example1(void *data) {
	auto ex = static_cast<example1*>(data);
	ASSERT_EQ(1.0, ex->a);
	ASSERT_EQ(22, ex->b);
	ASSERT_EQ(32, ex->c);
	ASSERT_EQ(42, ex->d);
	ASSERT_EQ(4.4f, ex->e);
}

/*********** example 2 ************************/
const char *example2_descriptor = "{BJJDFD byte long1 long2 double1 float1 double2}";

static const char *avpr_example2_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Byte\", \
                    \"size\" : 1, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Slong\", \
                    \"size\" : 8, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Double\", \
                    \"size\" : 8, \
                    \"alias\" : \"double\" \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Float\", \
                    \"size\" : 4, \
                    \"alias\" : \"float\" \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structB\", \
                    \"fields\" : [{\
                        \"name\" : \"byte\", \
                        \"type\" : \"Byte\" \
                    }, {\
                        \"name\" : \"long1\", \
                        \"type\" : \"Slong\" \
                    }, {\
                        \"name\" : \"long2\", \
                        \"type\" : \"Slong\" \
                    }, {\
                        \"name\" : \"double1\", \
                        \"type\" : \"Double\" \
                    }, {\
                        \"name\" : \"float1\", \
                        \"type\" : \"Float\" \
                    }, {\
                        \"name\" : \"double2\", \
                        \"type\" : \"Double\" \
                    }]\
                }], \
                \"messages\" : {} \
            }";

static const char *avpr_example2_fqn = "test.ns.structB";

const char *example2_input = "{ \
    \"byte\" : 42, \
    \"long1\" : 232, \
    \"long2\" : 242, \
    \"double1\" : 4.2, \
    \"float1\" : 3.2, \
    \"double2\" : 4.4 \
}";

struct example2 {
	char byte;      //0
	int64_t long1;     //1
	int64_t long2;     //2
	double double1; //3
	float float1;   //4
	double double2; //5
};

static void check_example2(void *data) {
    auto ex = static_cast<example2*>(data);
	ASSERT_EQ(42, ex->byte);
	ASSERT_EQ(232, ex->long1);
	ASSERT_EQ(242, ex->long2);
	ASSERT_EQ(4.2, ex->double1);
	ASSERT_EQ(3.2f, ex->float1);
	ASSERT_EQ(4.4, ex->double2);
}


/*********** example 3 ************************/
/** sequence with a simple type **************/
const char *example3_descriptor = "{[I numbers}";

static const char *avpr_example3_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Sint\", \
                    \"size\" : 4, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structC\", \
                    \"fields\" : [{\
                        \"name\" : \"numbers\", \
                        \"type\" : {\
                            \"type\" : \"array\", \
                            \"items\" : \"Sint\", \
                            \"static\" : 3 \
                        }\
                    }]\
                }], \
                \"messages\" : {} \
            }";

static const char *avpr_example3_fqn = "test.ns.structC";

const char *example3_input = "{ \
    \"numbers\" : [22,32,42] \
}";

struct example3 {
	struct {
		uint32_t cap;
		uint32_t len;
		int32_t *buf;
	} numbers;
};

static void check_example3(void *data) {
    auto ex = static_cast<example3*>(data);
	ASSERT_EQ(3, ex->numbers.len);
	ASSERT_EQ(22, ex->numbers.buf[0]);
	ASSERT_EQ(32, ex->numbers.buf[1]);
	ASSERT_EQ(42, ex->numbers.buf[2]);
}

/*********** example 4 ************************/
/** structs within a struct (by reference)*******/
const char *example4_descriptor = "{{IDD index val1 val2}{IDD index val1 val2} left right}";

static const char *avpr_example4_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Int32\", \
                    \"size\" : 4, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Double\", \
                    \"size\" : 8, \
                    \"alias\" : \"double\" \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"leaf\", \
                    \"namespace\" : \"details\", \
                    \"fields\" : [{\
                        \"name\" : \"index\", \
                        \"type\" : \"test.ns.Int32\" \
                    }, {\
                        \"name\" : \"val1\", \
                        \"type\" : \"test.ns.Double\" \
                    }, {\
                        \"name\" : \"val2\", \
                        \"type\" : \"test.ns.Double\" \
                    }]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structD\", \
                    \"fields\" : [{\
                        \"name\" : \"left\", \
                        \"type\" : \"details.leaf\" \
                    }, {\
                        \"name\" : \"right\", \
                        \"type\" : \"details.leaf\" \
                    }]\
                }], \
                \"messages\" : {} \
            }";

static const char *avpr_example4_fqn = "test.ns.structD";

static const char *example4_input =  "{ \
    \"left\" : {\"index\":1, \"val1\":1.0, \"val2\":2.0 }, \
    \"right\" : {\"index\":2, \"val1\":5.0, \"val2\":4.0 } \
}";

struct ex4_leaf {
	int32_t index;
	double val1;
	double val2;
};

struct example4 {
	struct ex4_leaf left;
	struct ex4_leaf right;
};

static void check_example4(void *data) {
    auto ex = static_cast<example4*>(data);
	ASSERT_EQ(1, ex->left.index);
	ASSERT_EQ(1.0, ex->left.val1);
	ASSERT_EQ(2.0, ex->left.val2);
	ASSERT_EQ(2, ex->right.index);
	ASSERT_EQ(5.0, ex->right.val1);
	ASSERT_EQ(4.0, ex->right.val2);
}


/*********** example 5 ************************/
/** structs within a struct (by reference)*******/
const char *example5_descriptor = "Tleaf={ts name age};Tnode={Lnode;Lnode;Lleaf; left right value};{Lnode; head}";

static const char *avpr_example5_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Char\", \
                    \"size\" : 2 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Str\", \
                    \"size\" : 8, \
                    \"alias\" : \"string\" \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"leaf\", \
                    \"namespace\" : \"details\", \
                    \"fields\" : [{\
                        \"name\" : \"name\", \
                        \"type\" : \"test.ns.Str\" \
                    }, {\
                        \"name\" : \"age\", \
                        \"type\" : \"test.ns.Char\" \
                    }]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"node\", \
                    \"fields\" : [{\
                        \"name\" : \"left\", \
                        \"type\" : \"node\", \
                        \"ptr\" : true \
                    }, {\
                        \"name\" : \"right\", \
                        \"type\" : \"node\", \
                        \"ptr\" : true \
                    }, {\
                        \"name\" : \"value\", \
                        \"type\" : \"details.leaf\", \
                        \"ptr\" : true \
                    }]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structE\", \
                    \"fields\" : [{\
                        \"name\" : \"head\", \
                        \"type\" : \"node\", \
                        \"ptr\" : true \
                    }]\
                }], \
                \"messages\" : {} \
            }";

static const char *avpr_example5_fqn = "test.ns.structE";

static const char *example5_input =  "{ \
    \"head\" : {\
        \"left\" : {\
            \"value\" : {\
                \"name\" : \"John\",\
                \"age\" : 44 \
            },\
            \"left\" : {\
                \"value\" : {\
                    \"name\" : \"Victor\",\
                    \"age\" : 400 \
                }\
            }\
        },\
        \"right\" : {\
            \"value\" : {\
                \"name\" : \"Peter\", \
                \"age\" : 55 \
            }\
        }\
    }\
}";

struct leaf {
	const char *name;
	uint16_t age;
};

struct node {
	struct node *left;
	struct node *right;
	struct leaf *value;
};

struct example5 {
	struct node *head;
};

static void check_example5(void *data) {
    auto ex = static_cast<example5*>(data);
	ASSERT_TRUE(ex->head != nullptr);

	ASSERT_TRUE(ex->head->left != nullptr);
	ASSERT_TRUE(ex->head->left->value != nullptr);
	ASSERT_STREQ("John", ex->head->left->value->name);
	ASSERT_EQ(44, ex->head->left->value->age);
	ASSERT_TRUE(ex->head->left->right == nullptr);
	ASSERT_TRUE(ex->head->left->left != nullptr);
	ASSERT_TRUE(ex->head->left->left->value != nullptr);
	ASSERT_STREQ("Victor", ex->head->left->left->value->name);
	ASSERT_EQ(400, ex->head->left->left->value->age);

	ASSERT_TRUE(ex->head->right != nullptr);
	ASSERT_TRUE(ex->head->right->value != nullptr);
	ASSERT_STREQ("Peter", ex->head->right->value->name);
	ASSERT_EQ(55, ex->head->right->value->age);
	ASSERT_TRUE(ex->head->right->left == nullptr);
	ASSERT_TRUE(ex->head->right->right == nullptr);
}

/*********** example 6 ************************/
static const char *example6_descriptor = "Tsample={DD v1 v2};[lsample;";

static const char *avpr_example6_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Double\", \
                    \"alias\" : \"double\", \
                    \"size\" : 8 \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"sample\", \
                    \"fields\" : [{\
                        \"name\" : \"v1\", \
                        \"type\" : \"Double\" \
                    }, {\
                        \"name\" : \"v2\", \
                        \"type\" : \"Double\" \
                    }]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structF\", \
                    \"fields\" : [{\
                        \"name\" : \"samples\", \
                        \"type\" : { \
                            \"type\" : \"array\",\
                            \"items\" : \"sample\"\
                        }\
                    }]\
                }], \
                \"messages\" : {} \
            }";
static const char *avpr_example6_fqn = "test.ns.structF";

static const char *example6_input = R"([{"v1":0.1,"v2":0.2},{"v1":1.1,"v2":1.2},{"v1":2.1,"v2":2.2}])";
static const char *avpr_example6_input = R"({
    "samples" : [{"v1":0.1,"v2":0.2},{"v1":1.1,"v2":1.2},{"v1":2.1,"v2":2.2}]
})";

struct ex6_sample {
	double v1;
	double v2;
};

struct ex6_sequence {
	uint32_t cap;
	uint32_t len;
	struct ex6_sample *buf;
};

struct ex6_avpr_struct {
    struct ex6_sequence samples;
};

static void check_example6(struct ex6_sequence seq) {
	ASSERT_EQ(3, seq.cap);
	ASSERT_EQ(3, seq.len);
	ASSERT_EQ(0.1, seq.buf[0].v1);
	ASSERT_EQ(0.2, seq.buf[0].v2);
	ASSERT_EQ(1.1, seq.buf[1].v1);
	ASSERT_EQ(1.2, seq.buf[1].v2);
	ASSERT_EQ(2.1, seq.buf[2].v1);
	ASSERT_EQ(2.2, seq.buf[2].v2);
}

static void check_example6_avpr(void *data) {
    auto ex = static_cast<ex6_avpr_struct*>(data);
	ASSERT_EQ(3, ex->samples.cap);
	ASSERT_EQ(3, ex->samples.len);
	ASSERT_EQ(0.1, ex->samples.buf[0].v1);
	ASSERT_EQ(0.2, ex->samples.buf[0].v2);
	ASSERT_EQ(1.1, ex->samples.buf[1].v1);
	ASSERT_EQ(1.2, ex->samples.buf[1].v2);
	ASSERT_EQ(2.1, ex->samples.buf[2].v1);
	ASSERT_EQ(2.2, ex->samples.buf[2].v2);
}

/*********** example 7 ************************/
const char *example7_descriptor = "{t a}";

static const char *avpr_example7_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Str\", \
                    \"size\" : 8, \
                    \"alias\" : \"string\" \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structG\", \
                    \"fields\" : [{\
                        \"name\" : \"a\", \
                        \"type\" : \"Str\" \
                    }]\
                }], \
                \"messages\" : {} \
            }";


static const char *avpr_example7_fqn = "test.ns.structG";

const char *example7_input = "{ \
    \"a\" : \"apache celix\" \
}";

struct example7 {
	char* a;   //0
};

static void check_example7(void *data) {
    auto ex = static_cast<example7*>(data);
	ASSERT_STREQ("apache celix", ex->a);
}


/*********** example 8 ************************/

const char *example8_descriptor = "{ZbijNP a b c d e f}";

static const char *avpr_example8_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Bool\", \
                    \"alias\" : \"boolean\", \
                    \"size\" : 1 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"UChar\", \
                    \"size\" : 1 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Uint\", \
                    \"size\" : 4 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Ulong\", \
                    \"size\" : 8 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Sint\", \
                    \"size\" : 4, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"VoidPtr\", \
                    \"size\" : 1, \
                    \"alias\" : \"void_ptr\" \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structH\", \
                    \"fields\" : [{\
                        \"name\" : \"a\", \
                        \"type\" : \"Bool\" \
                    }, {\
                        \"name\" : \"b\", \
                        \"type\" : \"UChar\" \
                    }, {\
                        \"name\" : \"c\", \
                        \"type\" : \"Uint\" \
                    }, {\
                        \"name\" : \"d\", \
                        \"type\" : \"Ulong\" \
                    }, {\
                        \"name\" : \"e\", \
                        \"type\" : \"Sint\" \
                    }, {\
                        \"name\" : \"f\", \
                        \"type\" : \"VoidPtr\" \
                    }]\
                }], \
                \"messages\" : {} \
            }";


static const char *avpr_example8_fqn = "test.ns.structH";

const char *example8_input = "{ \
    \"a\" : true, \
    \"b\" : 4, \
    \"c\" : 8, \
    \"d\" : 16, \
    \"e\" : 32 \
}";

struct example8 {
	bool a;
	unsigned char b;
	uint32_t c;
	uint64_t d;
	int e;
	void* f;
};

static void check_example8(void *data) {
    auto ex = static_cast<example8*>(data);
	ASSERT_EQ(true,ex->a);
	ASSERT_EQ(4,ex->b);
	ASSERT_EQ(8,ex->c);
	//error on mac ASSERT_EQ(16,ex->d);
    ASSERT_TRUE(16 == ex->d);
	ASSERT_EQ(32,ex->e);
}

/*********** example 9 ************************/
const char *example9_descriptor = "{It#OK=0;#NOK=1;#MAYBE=2;E id name result}";

static const char *avpr_example9_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"2.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Sint\", \
                    \"size\" : 4, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"String\", \
                    \"alias\" : \"string\", \
                    \"size\" : 8 \
                }, { \
                    \"type\" : \"enum\", \
                    \"name\" : \"ResultEnum\", \
                    \"EnumValues\" : [ \"OK = 0\", \"NOK=  1\", \"MAYBE  =2\" ],\
                    \"symbols\" : [\"OK\", \"NOK\", \"MAYBE\" ]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structI\", \
                    \"fields\" : [{\
                        \"name\" : \"id\", \
                        \"type\" : \"Sint\" \
                    }, {\
                        \"name\" : \"name\", \
                        \"type\" : \"String\" \
                    }, {\
                        \"name\" : \"result\", \
                        \"type\" : \"ResultEnum\" \
                    }]\
                }], \
                \"messages\" : {} \
            }";

static const char *avpr_example9_fqn = "test.ns.structI";

const char *example9_input_1 = "{\
                                \"id\"   : 1000, \
                                \"name\" : \"my_name\", \
                                \"result\" : \"NOK\" \
                                }";

const char *example9_input_2 = "{\
                                \"id\"   : 1001, \
                                \"name\" : \"your_name\", \
                                \"result\" : \"MAYBE\" \
                                }";

const char *example9_input_3 =
        R"({
            "id" : 1001,
            "name" : "your_name",
            "result" : "OK"
        })";

enum ResultEnum {
    RE_OK = 0,
    RE_NOK = 1,
    RE_MAYBE = 2
};

struct example9 {
    int32_t id;
    char * name;
    enum ResultEnum result;
};

static void check_example9_1(void *data) {
    auto ex = static_cast<example9*>(data);
    ASSERT_EQ(1000, ex->id);
    ASSERT_STREQ("my_name", ex->name);
    ASSERT_EQ(RE_NOK, ex->result);
}

static void check_example9_2(void *data) {
    auto ex = static_cast<example9*>(data);
    ASSERT_EQ(1001, ex->id);
    ASSERT_STREQ("your_name", ex->name);
    ASSERT_EQ(RE_MAYBE, ex->result);
}

static void check_example9_3(void *data) {
    auto ex = static_cast<example9*>(data);
    ASSERT_EQ(1001, ex->id);
    ASSERT_STREQ("your_name", ex->name);
    ASSERT_EQ(RE_OK, ex->result);
}
/*********** example A ************************/
const char *exampleA_descriptor = "TPoint={DD x y};{lPoint;lPoint;t point_a point_b name}";

const char *exampleA_input =
		R"({
"point_a" : { "x" : 1.0, "y" : 2.0 },
"point_b" : { "x" : 3.0, "y" : 4.0 },
"name" : "this_is_my_name"
})";

struct exA_point {
	double x;
	double y;
};

struct exA_struct {
	exA_point point_a;
	exA_point point_b;
	char* name;
};

static void check_exampleA(void *data) {
	auto inp = static_cast<exA_struct*>(data);
	ASSERT_EQ(1.0, inp->point_a.x);
	ASSERT_EQ(2.0, inp->point_a.y);
	ASSERT_EQ(3.0, inp->point_b.x);
	ASSERT_EQ(4.0, inp->point_b.y);
	ASSERT_STREQ("this_is_my_name", inp->name);
}


static void parseAvprTests() {
	dyn_type *type;
	void *inst;
    int rc;

    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example1_descriptor, avpr_example1_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, example1_input, strlen(example1_input), &inst);
	ASSERT_EQ(0, rc);
	check_example1(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example2_descriptor, avpr_example2_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, example2_input, strlen(example2_input), &inst);
	ASSERT_EQ(0, rc);
	check_example2(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example3_descriptor, avpr_example3_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, example3_input, strlen(example3_input), &inst);
	ASSERT_EQ(0, rc);
	check_example3(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example4_descriptor, avpr_example4_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, example4_input, strlen(example4_input), &inst);
	ASSERT_EQ(0, rc);
	check_example4(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example5_descriptor, avpr_example5_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, example5_input, strlen(example5_input), &inst);
	ASSERT_EQ(0, rc);
	check_example5(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    // Test 6 has custom checker because avdl does not allow an array to be a type on its own
    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example6_descriptor, avpr_example6_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, avpr_example6_input, strlen(avpr_example6_input), &inst);
	ASSERT_EQ(0, rc);
	check_example6_avpr(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example7_descriptor, avpr_example7_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, example7_input, strlen(example7_input), &inst);
	ASSERT_EQ(0, rc);
	check_example7(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example8_descriptor, avpr_example8_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, example8_input, strlen(example8_input), &inst);
	ASSERT_EQ(0, rc);
	check_example8(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    inst = nullptr;
    type = dynType_parseAvprWithStr(avpr_example9_descriptor, avpr_example9_fqn);
    ASSERT_TRUE(type != nullptr);
	rc = jsonSerializer_deserialize(type, example9_input_1, strlen(example9_input_1), &inst);
	ASSERT_EQ(0, rc);
	check_example9_1(inst);
	dynType_free(type, inst);
	rc = jsonSerializer_deserialize(type, example9_input_2, strlen(example9_input_2), &inst);
	ASSERT_EQ(0, rc);
	check_example9_2(inst);
	dynType_free(type, inst);
    rc = jsonSerializer_deserialize(type, example9_input_3, strlen(example9_input_3), &inst);
    ASSERT_EQ(0, rc);
    check_example9_3(inst);
    dynType_free(type, inst);
	dynType_destroy(type);
}

static void parseTests() {
	dyn_type *type;
	void *inst;
	int rc;

	type = nullptr;
	inst = nullptr;
	rc = dynType_parseWithStr(example1_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example1_input, strlen(example1_input), &inst);
	ASSERT_EQ(0, rc);
	check_example1(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

	type = nullptr;
	inst = nullptr;
	rc = dynType_parseWithStr(example2_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example2_input, strlen(example2_input), &inst);
	ASSERT_EQ(0, rc);
	check_example2(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

	type = nullptr;
	inst = nullptr;
	rc = dynType_parseWithStr(example3_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example3_input, strlen(example3_input), &inst);
	ASSERT_EQ(0, rc);
	check_example3(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

	type = nullptr;
	inst = nullptr;
	rc = dynType_parseWithStr(example4_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example4_input, strlen(example4_input), &inst);
	ASSERT_EQ(0, rc);
	check_example4(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

	type = nullptr;
	inst = nullptr;
	rc = dynType_parseWithStr(example5_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example5_input, strlen(example5_input), &inst);
	ASSERT_EQ(0, rc);
	check_example5(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

	type = nullptr;
	struct ex6_sequence *seq;
	rc = dynType_parseWithStr(example6_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example6_input, strlen(example6_input), (void **)&seq);
	ASSERT_EQ(0, rc);
	check_example6((*seq));
	dynType_free(type, seq);
	dynType_destroy(type);

	type = nullptr;
	inst = nullptr;
	rc = dynType_parseWithStr(example7_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example7_input, strlen(example7_input), &inst);
	ASSERT_EQ(0, rc);
	check_example7(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

	type = nullptr;
	inst = nullptr;
	rc = dynType_parseWithStr(example8_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example8_input, strlen(example8_input), &inst);
	ASSERT_EQ(0, rc);
	check_example8(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

	type = nullptr;
	inst = nullptr;
	rc = dynType_parseWithStr(example9_descriptor, nullptr, nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_deserialize(type, example9_input_1, strlen(example9_input_1), &inst);
	ASSERT_EQ(0, rc);
	check_example9_1(inst);
	dynType_free(type, inst);
	rc = jsonSerializer_deserialize(type, example9_input_2, strlen(example9_input_2), &inst);
	ASSERT_EQ(0, rc);
	check_example9_2(inst);
	dynType_free(type, inst);
	dynType_destroy(type);

    type = nullptr;
    inst = nullptr;
    rc = dynType_parseWithStr(exampleA_descriptor, nullptr, nullptr, &type);
    ASSERT_EQ(0, rc);
    rc = jsonSerializer_deserialize(type, exampleA_input, strlen(exampleA_input), &inst);
    ASSERT_EQ(0, rc);
    check_exampleA(inst);
    dynType_free(type, inst);
    dynType_destroy(type);
}

/*********** write example 1 ************************/
const char *write_example1_descriptor = "{BSIJsijFDNZb a b c d e f g h i j k l}";

const char *avpr_write_example1_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"SChar\", \
                    \"signed\" : true, \
                    \"size\" : 1 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Short\", \
                    \"size\" : 2, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Sint\", \
                    \"size\" : 4, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Slong\", \
                    \"size\" : 8, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"UShort\", \
                    \"size\" : 2 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Uint\", \
                    \"size\" : 4 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Ulong\", \
                    \"size\" : 8 \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Float\", \
                    \"size\" : 4, \
                    \"alias\" : \"float\" \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Double\", \
                    \"size\" : 8, \
                    \"alias\" : \"double\" \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"NativeInt\", \
                    \"size\" : 4, \
                    \"alias\" : \"native_int\" \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Bool\", \
                    \"size\" : 1, \
                    \"alias\" : \"boolean\" \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"UChar\", \
                    \"size\" : 1 \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structAW\", \
                    \"fields\" : [{\
                        \"name\" : \"a\", \
                        \"type\" : \"SChar\" \
                    }, {\
                        \"name\" : \"b\", \
                        \"type\" : \"Short\" \
                    }, {\
                        \"name\" : \"c\", \
                        \"type\" : \"Sint\" \
                    }, {\
                        \"name\" : \"d\", \
                        \"type\" : \"Slong\" \
                    }, {\
                        \"name\" : \"e\", \
                        \"type\" : \"UShort\" \
                    }, {\
                        \"name\" : \"f\", \
                        \"type\" : \"Uint\" \
                    }, {\
                        \"name\" : \"g\", \
                        \"type\" : \"Ulong\" \
                    }, {\
                        \"name\" : \"h\", \
                        \"type\" : \"Float\" \
                    }, {\
                        \"name\" : \"i\", \
                        \"type\" : \"Double\" \
                    }, {\
                        \"name\" : \"j\", \
                        \"type\" : \"NativeInt\" \
                    }, {\
                        \"name\" : \"k\", \
                        \"type\" : \"Bool\" \
                    }, {\
                        \"name\" : \"l\", \
                        \"type\" : \"UChar\" \
                    }]\
                }], \
                \"messages\" : {} \
            }";

const char *avpr_write_example1_fqn = "test.ns.structAW";

struct write_example1 {
	char a;
	int16_t b;
	int32_t c;
	int64_t d;
	uint16_t e;
	uint32_t f;
	uint64_t g;
	float h;
	double i;
	int j;
	bool k;
	unsigned char l;
};

void writeTest1(void) {
	write_example1 ex1 {'A',2,3,4,5,6,7,8.8f,9.9,10,true,12};
	ex1.k = !ex1.k;

	dyn_type *type = nullptr;
	char *result = nullptr;
	int rc = dynType_parseWithStr(write_example1_descriptor, "ex1", nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_serialize(type, &ex1, &result);
	ASSERT_EQ(0, rc);
	ASSERT_TRUE(strstr(result, R"("b":2)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("c":3)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("d":4)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("e":5)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("f":6)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("g":7)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("h":8.8)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("i":9.9)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("j":10)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("k":false)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("l":12)") != nullptr);
	//printf("example 1 result: '%s'\n", result);
	dynType_destroy(type);
	free(result);
}

void writeAvprTest1(void) {
	write_example1 ex1 {1,2,3,4,5,6,7,8.8f,9.9,10,true,12};

	char *result = nullptr;
	dyn_type *type = dynType_parseAvprWithStr(avpr_write_example1_descriptor, avpr_write_example1_fqn);
	ASSERT_TRUE(type != nullptr);

	int rc = jsonSerializer_serialize(type, &ex1, &result);
	ASSERT_EQ(0, rc);

	ASSERT_TRUE(strstr(result, R"("a":1)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("b":2)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("c":3)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("d":4)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("e":5)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("f":6)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("g":7)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("h":8.8)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("i":9.9)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("j":10)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("k":true)") != nullptr);
    ASSERT_TRUE(strstr(result, R"("l":12)") != nullptr);

	dynType_destroy(type);
	free(result);
}

/*********** write example 2 ************************/
const char *write_example2_descriptor = "{*{JJ a b}{SS c d} sub1 sub2}";

const char *avpr_write_example2_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Short\", \
                    \"size\" : 2, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Slong\", \
                    \"size\" : 8, \
                    \"signed\" : true \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"SubPtr\", \
                    \"fields\" : [{\
                        \"name\" : \"a\", \
                        \"type\" : \"Slong\" \
                    }, {\
                        \"name\" : \"b\", \
                        \"type\" : \"Slong\" \
                    }]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"Sub\", \
                    \"fields\" : [{\
                        \"name\" : \"c\", \
                        \"type\" : \"Short\" \
                    }, {\
                        \"name\" : \"d\", \
                        \"type\" : \"Short\" \
                    }]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structBW\", \
                    \"fields\" : [{\
                        \"name\" : \"sub1\", \
                        \"ptr\" : true, \
                        \"type\" : \"SubPtr\" \
                    }, {\
                        \"name\" : \"sub2\", \
                        \"type\" : \"Sub\" \
                    }]\
                }], \
                \"messages\" : {} \
            }";

const char *avpr_write_example2_fqn = "test.ns.structBW";

struct write_example2_sub {
	int64_t a;
	int64_t b;
};

struct write_example2 {
	write_example2_sub *sub1;
	struct {
		int16_t c;
		int16_t d;
	};
};

void writeTest2(void) {
	write_example2_sub sub1 {1,2};
	write_example2 ex {&sub1, {3, 4}};

	dyn_type *type = nullptr;
	char *result = nullptr;
	int rc = dynType_parseWithStr(write_example2_descriptor, "ex2", nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_serialize(type, &ex, &result);
	ASSERT_EQ(0, rc);
	ASSERT_TRUE(strstr(result, "\"a\":1") != nullptr);
    ASSERT_TRUE(strstr(result, "\"b\":2") != nullptr);
    ASSERT_TRUE(strstr(result, "\"c\":3") != nullptr);
    ASSERT_TRUE(strstr(result, "\"d\":4") != nullptr);
	//printf("example 2 result: '%s'\n", result);
	dynType_destroy(type);
	free(result);
}

void writeAvprTest2(void) {
    write_example2_sub sub1 {0,0};
    write_example2 ex {&sub1, {3, 4}};
    ex.sub1->a = 1;
    ex.sub1->b = 2;

	char *result = nullptr;
	dyn_type *type = dynType_parseAvprWithStr(avpr_write_example2_descriptor, avpr_write_example2_fqn);
	ASSERT_TRUE(type != nullptr);

	int rc = jsonSerializer_serialize(type, &ex, &result);
	ASSERT_EQ(0, rc);

	ASSERT_TRUE(strstr(result, "\"a\":1") != nullptr);
    ASSERT_TRUE(strstr(result, "\"b\":2") != nullptr);
    ASSERT_TRUE(strstr(result, "\"c\":3") != nullptr);
    ASSERT_TRUE(strstr(result, "\"d\":4") != nullptr);

	dynType_destroy(type);
	free(result);
}

/*********** write example 3 ************************/
const char *write_example3_descriptor = "Tperson={ti name age};[Lperson;";

const char *avpr_write_example3_descriptor = "{\
                \"protocol\" : \"types\", \
                \"namespace\" : \"test.ns\", \
                \"version\" : \"1.0.0\", \
                \"types\" : [ { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Str\", \
                    \"size\" : 8, \
                    \"alias\" : \"string\" \
                }, { \
                    \"type\" : \"fixed\", \
                    \"name\" : \"Uint\", \
                    \"size\" : 4 \
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"PersonPtr\", \
                    \"fields\" : [{\
                        \"name\" : \"p\", \
                        \"type\" : \"Person\", \
                        \"ptr\" : true \
                    }]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"Person\", \
                    \"fields\" : [{\
                        \"name\" : \"name\", \
                        \"type\" : \"Str\" \
                    }, {\
                        \"name\" : \"age\", \
                        \"type\" : \"Uint\" \
                    }]\
                }, { \
                    \"type\" : \"record\", \
                    \"name\" : \"structCW\", \
                    \"fields\" : [{\
                        \"name\" : \"persons\", \
                        \"type\" : { \
                            \"type\" : \"array\",\
                            \"items\" : \"PersonPtr\"\
                        }\
                    }]\
                }], \
                \"messages\" : {} \
            }";

const char *avpr_write_example3_fqn = "test.ns.structCW";

struct write_example3_person {
	const char *name;
	uint32_t age;
};

struct write_example3 {
	uint32_t cap;
	uint32_t len;
	write_example3_person **buf;
};

void writeTest3(void) {
	write_example3_person p1 {"John", 33};
	write_example3_person p2 {"Peter", 44};
	write_example3_person p3 {"Carol", 55};
	write_example3_person p4 {"Elton", 66};

	write_example3 seq {4, 4, (struct write_example3_person **) calloc(4, sizeof(void *))};
	seq.buf[0] = &p1;
	seq.buf[1] = &p2;
	seq.buf[2] = &p3;
	seq.buf[3] = &p4;

	dyn_type *type = nullptr;
	char *result = nullptr;
	int rc = dynType_parseWithStr(write_example3_descriptor, "ex3", nullptr, &type);
	ASSERT_EQ(0, rc);
	rc = jsonSerializer_serialize(type, &seq, &result);
	ASSERT_EQ(0, rc);
	ASSERT_TRUE(strstr(result, "\"age\":33") != nullptr);
    ASSERT_TRUE(strstr(result, "\"age\":44") != nullptr);
    ASSERT_TRUE(strstr(result, "\"age\":55") != nullptr);
    ASSERT_TRUE(strstr(result, "\"age\":66") != nullptr);
	//printf("example 3 result: '%s'\n", result);
	free(seq.buf);
	dynType_destroy(type);
	free(result);
}

void writeAvprTest3(void) {
    write_example3_person p1 {"John", 33};
    write_example3_person p2 {"Peter", 44};
    write_example3_person p3 {"Carol", 55};
    write_example3_person p4 {"Elton", 66};

    write_example3 seq {4, 4, (write_example3_person **) calloc(4, sizeof(void *))};
    seq.buf[0] = &p1;
    seq.buf[1] = &p2;
    seq.buf[2] = &p3;
    seq.buf[3] = &p4;

	char *result = nullptr;
	dyn_type *type = dynType_parseAvprWithStr(avpr_write_example3_descriptor, avpr_write_example3_fqn);
    ASSERT_TRUE(type != nullptr);

	int rc = jsonSerializer_serialize(type, &seq, &result);
	ASSERT_EQ(0, rc);

    ASSERT_TRUE(strstr(result, "\"age\":33") != nullptr);
    ASSERT_TRUE(strstr(result, "\"age\":44") != nullptr);
    ASSERT_TRUE(strstr(result, "\"age\":55") != nullptr);
    ASSERT_TRUE(strstr(result, "\"age\":66") != nullptr);

	free(seq.buf);
	dynType_destroy(type);
	free(result);
}

} // extern "C"


class JsonSerializerTests : public ::testing::Test {
public:
    JsonSerializerTests() {
        int lvl = 1;
        dynCommon_logSetup(stdLog, nullptr, lvl);
        dynType_logSetup(stdLog, nullptr,lvl);
        dynAvprType_logSetup(stdLog, nullptr,lvl);
        dynTypeCommon_logSetup(stdLog, nullptr,lvl);
        jsonSerializer_logSetup(stdLog, nullptr, lvl);
    }
    ~JsonSerializerTests() override {
    }

};

TEST_F(JsonSerializerTests, ParseTests) {
	parseTests();
}

TEST_F(JsonSerializerTests, ParseAvprTests) {
    parseAvprTests();
}

TEST_F(JsonSerializerTests, WriteTest1) {
	writeTest1();
    writeAvprTest1();
}

TEST_F(JsonSerializerTests, WriteTest2) {
	writeTest2();
    writeAvprTest2();
}

TEST_F(JsonSerializerTests, WriteTest3) {
	writeTest3();
    writeAvprTest3();
}