702 lines
22 KiB
C
702 lines
22 KiB
C
/*
|
|
* Copyright (c) 2017-2025, Patrick Pelissier
|
|
* All rights reserved.
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* + Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* + 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 REGENTS 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 REGENTS AND 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 "test-obj.h"
|
|
#include "m-tuple.h"
|
|
#include "m-array.h"
|
|
#include "m-variant.h"
|
|
#include "m-list.h"
|
|
#include "m-dict.h"
|
|
#include "coverage.h"
|
|
|
|
#include "m-serial-json.h"
|
|
|
|
// Serial json is not supported for standard types if not C11
|
|
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
|
|
|
|
ARRAY_DEF(a2, int)
|
|
#define M_OPL_a2_t() ARRAY_OPLIST(a2, M_BASIC_OPLIST)
|
|
|
|
ARRAY_DEF(l2, int)
|
|
#define M_OPL_l2_t() ARRAY_OPLIST(l2, M_BASIC_OPLIST)
|
|
|
|
DICT_DEF2(d2, string_t, STRING_OPLIST, int, M_BASIC_OPLIST )
|
|
#define M_OPL_d2_t() DICT_OPLIST(d2, STRING_OPLIST, M_BASIC_OPLIST)
|
|
|
|
VARIANT_DEF2(v2,
|
|
(is_int, int),
|
|
(is_bool, bool) )
|
|
#define M_OPL_v2_t() VARIANT_OPLIST(v2, M_BASIC_OPLIST, M_BASIC_OPLIST)
|
|
|
|
typedef enum {
|
|
SUCCESS = 0, NULL_PARAM, INVALID_PARAM
|
|
} my_return_code_t;
|
|
#define M_OPL_my_return_code_t() M_ENUM_OPLIST(my_return_code_t, SUCCESS)
|
|
|
|
TUPLE_DEF2(my,
|
|
(vala, int),
|
|
(valb, float),
|
|
(valc, bool),
|
|
(vald, string_t),
|
|
(vale, a2_t),
|
|
(valf, v2_t),
|
|
(valg, l2_t),
|
|
(valh, d2_t),
|
|
(vali, my_return_code_t)
|
|
)
|
|
#define M_OPL_my_t() TUPLE_OPLIST(my, M_BASIC_OPLIST, M_BASIC_OPLIST, M_BASIC_OPLIST, STRING_OPLIST, M_OPL_a2_t(), M_OPL_v2_t(), M_OPL_l2_t(), M_OPL_d2_t(), M_OPL_my_return_code_t() )
|
|
|
|
TUPLE_DEF2(my2,
|
|
(activated, bool),
|
|
(data, my_t, M_OPL_my_t() ) )
|
|
|
|
static void test_out_empty(void)
|
|
{
|
|
m_serial_read_t in;
|
|
m_serial_write_t out;
|
|
m_serial_return_code_t ret;
|
|
my2_t el1, el2;
|
|
my2_init(el1);
|
|
my2_init(el2);
|
|
|
|
FILE *f = m_core_fopen ("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
m_serial_json_write_init(out, f);
|
|
ret = my2_out_serial(out, el1);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
m_serial_json_write_clear(out);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
static const char expected[] = "{ \"activated\":false,\"data\":{ \"vala\":0,\"valb\":0.000000,\"valc\":false,\"vald\":\"\",\"vale\":[],\"valf\":{},\"valg\":[],\"valh\":{},\"vali\":0}";
|
|
char get[sizeof expected];
|
|
char *unused = fgets (get, sizeof expected , f);
|
|
assert (unused != NULL && strcmp(get, expected) == 0);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el2, in);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
assert (my2_equal_p (el1, el2));
|
|
|
|
my2_clear(el1);
|
|
my2_clear(el2);
|
|
}
|
|
|
|
static void test_out_fill(void)
|
|
{
|
|
m_serial_read_t in;
|
|
m_serial_write_t out;
|
|
m_serial_return_code_t ret;
|
|
my2_t el1, el2;
|
|
my2_init(el1);
|
|
my2_init(el2);
|
|
|
|
FILE *f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true } }\n");
|
|
fclose(f);
|
|
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el2, in);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen ("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
m_serial_json_write_init(out, f);
|
|
ret = my2_out_serial(out, el2);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
m_serial_json_write_clear(out);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
static const char expected[] = "{ \"activated\":false,\"data\":{ \"vala\":1742,\"valb\":-2.300000,\"valc\":true,\"vald\":\"This is a test\",\"vale\":[1,2,3],\"valf\":{\"is_bool\":true},\"valg\":[1,2,3,4,5,6],\"valh\":{\"steeve\":-4,\"jane\":3},\"vali\":3}}";
|
|
static const char expected2[] = "{ \"activated\":false,\"data\":{ \"vala\":1742,\"valb\":-2.300000,\"valc\":true,\"vald\":\"This is a test\",\"vale\":[1,2,3],\"valf\":{\"is_bool\":true},\"valg\":[1,2,3,4,5,6],\"valh\":{\"jane\":3,\"steeve\":-4},\"vali\":3}}";
|
|
char get[sizeof expected];
|
|
char *unused2 = fgets (get, sizeof expected , f);
|
|
assert(unused2 != NULL);
|
|
// Workaround string literal of length 4350 exceeds maximum length 4095
|
|
if (!(strcmp(get, expected) == 0 || strcmp(get, expected2) == 0))
|
|
assert (0);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el1, in);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
assert (my2_equal_p (el1, el2));
|
|
|
|
my2_clear(el1);
|
|
my2_clear(el2);
|
|
}
|
|
|
|
static void test_out_str_empty(void)
|
|
{
|
|
m_serial_read_t in;
|
|
m_serial_write_t out;
|
|
m_serial_return_code_t ret;
|
|
my2_t el1, el2;
|
|
my2_init(el1);
|
|
my2_init(el2);
|
|
|
|
string_t f;
|
|
string_init(f);
|
|
m_serial_str_json_write_init(out, f);
|
|
ret = my2_out_serial(out, el1);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
m_serial_str_json_write_clear(out);
|
|
|
|
static const char expected[] = "{ \"activated\":false,\"data\":{ \"vala\":0,\"valb\":0.000000,\"valc\":false,\"vald\":\"\",\"vale\":[],\"valf\":{},\"valg\":[],\"valh\":{},\"vali\":0}";
|
|
assert (string_equal_str_p(f, expected) == 0);
|
|
|
|
m_serial_str_json_read_init(in, string_get_cstr(f) );
|
|
ret = my2_in_serial(el2, in);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
const char *end = m_serial_str_json_read_clear(in);
|
|
assert (*end == 0);
|
|
|
|
assert (my2_equal_p (el1, el2));
|
|
|
|
my2_clear(el1);
|
|
my2_clear(el2);
|
|
string_clear(f);
|
|
}
|
|
|
|
static void test_out_str_fill(void)
|
|
{
|
|
m_serial_read_t in;
|
|
m_serial_write_t out;
|
|
m_serial_return_code_t ret;
|
|
my2_t el1, el2;
|
|
my2_init(el1);
|
|
my2_init(el2);
|
|
|
|
string_t f;
|
|
string_init(f);
|
|
string_init_set_str(f,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true } }\n");
|
|
|
|
m_serial_str_json_read_init(in, string_get_cstr(f) );
|
|
ret = my2_in_serial(el2, in);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
const char *end = m_serial_str_json_read_clear(in);
|
|
assert (*end == '\n');
|
|
string_reset(f);
|
|
|
|
m_serial_str_json_write_init(out, f);
|
|
ret = my2_out_serial(out, el2);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
m_serial_str_json_write_clear(out);
|
|
|
|
// In function of the precise hashing (different between 64 bits & 32 bits), both strings are possible:
|
|
static const char expected[] = "{ \"activated\":false,\"data\":{ \"vala\":1742,\"valb\":-2.300000,\"valc\":true,\"vald\":\"This is a test\",\"vale\":[1,2,3],\"valf\":{\"is_bool\":true},\"valg\":[1,2,3,4,5,6],\"valh\":{\"steeve\":-4,\"jane\":3},\"vali\":3}}";
|
|
static const char expected2[] = "{ \"activated\":false,\"data\":{ \"vala\":1742,\"valb\":-2.300000,\"valc\":true,\"vald\":\"This is a test\",\"vale\":[1,2,3],\"valf\":{\"is_bool\":true},\"valg\":[1,2,3,4,5,6],\"valh\":{\"jane\":3,\"steeve\":-4},\"vali\":3}}";
|
|
assert(string_equal_str_p(f, expected) || string_equal_str_p(f, expected2) );
|
|
|
|
m_serial_str_json_read_init(in, string_get_cstr(f) );
|
|
ret = my2_in_serial(el1, in);
|
|
assert (ret == M_SERIAL_OK_DONE);
|
|
end = m_serial_str_json_read_clear(in);
|
|
assert (*end == 0);
|
|
|
|
assert (my2_equal_p (el1, el2));
|
|
|
|
my2_clear(el1);
|
|
my2_clear(el2);
|
|
string_clear(f);
|
|
}
|
|
|
|
static void test_out_error(void)
|
|
{
|
|
m_serial_read_t in;
|
|
m_serial_return_code_t ret;
|
|
my2_t el;
|
|
my2_init(el);
|
|
|
|
FILE *f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"\n ");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"[{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"{\n"
|
|
" \"activated22\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"{\n"
|
|
" \"\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"{\n"
|
|
" \"}");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"{\n"
|
|
" \"activated\":ealse,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_tmp\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true } }");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6], }\n");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
f = m_core_fopen("a-mjson.dat", "wt");
|
|
if (!f) abort();
|
|
fprintf(f,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
fclose(f);
|
|
f = m_core_fopen ("a-mjson.dat", "rt");
|
|
if (!f) abort();
|
|
m_serial_json_read_init(in, f);
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_json_read_clear(in);
|
|
fclose(f);
|
|
|
|
my2_clear(el);
|
|
}
|
|
|
|
static void test_out_str_error(void)
|
|
{
|
|
m_serial_read_t in;
|
|
m_serial_return_code_t ret;
|
|
my2_t el;
|
|
string_t s;
|
|
my2_init(el);
|
|
string_init(s);
|
|
|
|
string_set_str(s,
|
|
"\n ");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"[{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activated22\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"}");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activated\":ealse,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_tmp\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true } }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6], }\n");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivatedactivated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true } }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": (1,2,3),\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }}");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": [ \"jane\": 3, \"steeve\": -4 ],\n"
|
|
"\"valf\": { \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true } }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
string_set_str(s,
|
|
"{\n"
|
|
" \"activated\":false,\n"
|
|
"\"data\": {\n"
|
|
" \"valb\": -2.300000 , \n"
|
|
"\"vale\": [1,2,3],\n"
|
|
"\"valg\": [1,2,3,4,5,6],\n"
|
|
"\"valh\": { \"jane\": 3, \"steeve\": -4 },\n"
|
|
"\"valf\": [] \"is_bool\": true },\n"
|
|
" \"vala\":1742,\n"
|
|
" \"vald\": \"This is a test\",\n"
|
|
"\"vali\": 3,"
|
|
" \"valc\": true }");
|
|
m_serial_str_json_read_init(in, string_get_cstr(s));
|
|
ret = my2_in_serial(el, in);
|
|
assert (ret == M_SERIAL_FAIL);
|
|
m_serial_str_json_read_clear(in);
|
|
|
|
my2_clear(el);
|
|
string_clear(s);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
test_out_empty();
|
|
test_out_fill();
|
|
test_out_error();
|
|
test_out_str_empty();
|
|
test_out_str_fill();
|
|
test_out_str_error();
|
|
exit(0);
|
|
}
|
|
|
|
#else
|
|
int main(void)
|
|
{
|
|
exit(0);
|
|
}
|
|
#endif
|