From 7ba10055757eb6f3a60bc3fa5254482ef2abbf71 Mon Sep 17 00:00:00 2001 From: "Paul J. Davis" Date: Wed, 15 Mar 2017 12:12:08 -0500 Subject: [PATCH 1/5] Allow for pre-encoded JSON during encoding This change allows users to insert pre-encoded JSON `iodata()` anywhere there can be a valid `json_value()` (i.e., anywhere except object keys). This approach occurred to me looking at PR #139 from @dhull. The technical difference being that this approach does not copy the given `iodata()` into the output and instead re-uses the same input term as part of the output `iodata()`. --- c_src/encoder.c | 7 +++++-- src/jiffy.erl | 2 ++ 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/c_src/encoder.c b/c_src/encoder.c index afc3c146..5618da00 100644 --- a/c_src/encoder.c +++ b/c_src/encoder.c @@ -781,8 +781,11 @@ encode_iter(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) } } else if(enif_get_tuple(env, curr, &arity, &tuple)) { if(arity != 1) { - ret = enc_obj_error(e, "invalid_ejson", curr); - goto done; + if(!enc_unknown(e, curr)) { + ret = enc_error(e, "internal_error"); + goto done; + } + continue; } if(!enif_is_list(env, tuple[0])) { ret = enc_obj_error(e, "invalid_object", curr); diff --git a/src/jiffy.erl b/src/jiffy.erl index 0d9b7e41..d42c22cc 100644 --- a/src/jiffy.erl +++ b/src/jiffy.erl @@ -160,6 +160,8 @@ finish_encode([<<_/binary>>=B | Rest], Acc) -> finish_encode([Val | Rest], Acc) when is_integer(Val) -> Bin = list_to_binary(integer_to_list(Val)), finish_encode(Rest, [Bin | Acc]); +finish_encode([{json, Json} | Rest], Acc) -> + finish_encode(Rest, [Json | Acc]); finish_encode([InvalidEjson | _], _) -> throw({error, {invalid_ejson, InvalidEjson}}); finish_encode(_, _) -> From 654a8a480e1f95ba410df7bc32cbfc2925dc1ca0 Mon Sep 17 00:00:00 2001 From: David Hull Date: Thu, 16 Mar 2017 15:59:02 +0000 Subject: [PATCH 2/5] Unit tests for pre-encoded JSON. --- src/jiffy.erl | 5 ++- test/jiffy_18_preencode_tests.erl | 53 +++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 1 deletion(-) create mode 100644 test/jiffy_18_preencode_tests.erl diff --git a/src/jiffy.erl b/src/jiffy.erl index d42c22cc..88c19254 100644 --- a/src/jiffy.erl +++ b/src/jiffy.erl @@ -16,7 +16,8 @@ | json_string() | json_number() | json_object() - | json_array(). + | json_array() + | json_preencoded(). -type json_array() :: [json_value()]. -type json_string() :: atom() | binary(). @@ -33,6 +34,8 @@ -endif. +-type json_preencoded() :: {json, Json::iodata()}. + -type jiffy_decode_result() :: json_value() | {has_trailer, json_value(), binary()}. diff --git a/test/jiffy_18_preencode_tests.erl b/test/jiffy_18_preencode_tests.erl new file mode 100644 index 00000000..5bc36bf4 --- /dev/null +++ b/test/jiffy_18_preencode_tests.erl @@ -0,0 +1,53 @@ +-module(jiffy_18_preencode_tests). + + +-include_lib("eunit/include/eunit.hrl"). +-include("jiffy_util.hrl"). + + +preencode_success_test_() -> + [gen(ok, Case) || Case <- cases(ok)]. + + +%% preencode_failure_test_() -> +%% [gen(error, Case) || Case <- cases(error)]. + + +gen(ok, {E1, J, E2}) -> + {msg("~p", [E1]), [ + {"Encode", ?_assertEqual(J, enc(E1))}, + {"Decode", ?_assertEqual(E2, dec(J))} + ]}. + +%% gen(error, E) -> +%% {msg("Error: ~p", [E]), [ +%% ?_assertThrow({error, _}, enc(E)) +%% ]}. + + +cases(ok) -> + TopTests = + lists:map( + fun (EJSON) -> + JSON = enc(EJSON), + {{json, JSON}, JSON, EJSON} + end, [ 123 + , <<"hello world">> + , true + , false + , {[ {<<"a">>, <<"apple">>}, {<<"b">>, <<"banana">>} ]} + ]), + EJSON = [ 1, <<"a">> ], + JSON = enc(EJSON), + BuriedTests = + [ { [ {json, JSON} ], <<"[[1,\"a\"]]">>, [ EJSON ]} + , { [ 1, {json, JSON}, 3 ], <<"[1,[1,\"a\"],3]">>, [ 1, EJSON, 3 ]} + , { [ {json, JSON}, {json, JSON} ], <<"[[1,\"a\"],[1,\"a\"]]">>, [ EJSON, EJSON ]} + , { {[ {<<"a">>, {json, JSON}} ]}, <<"{\"a\":[1,\"a\"]}">>, {[ {<<"a">>, EJSON} ]}} + ], + TopTests ++ BuriedTests. + +%% cases(error) -> +%% [ {json, true} +%% , {json, "true"} +%% ]. From fd61193dd8b5b4d15c76b1eb79a0df3a191ede70 Mon Sep 17 00:00:00 2001 From: David Hull Date: Wed, 15 Mar 2017 16:39:21 +0000 Subject: [PATCH 3/5] Refactor common object encoding to new function enc_object_element. --- c_src/encoder.c | 115 ++++++++++++++++++++---------------------------- 1 file changed, 47 insertions(+), 68 deletions(-) diff --git a/c_src/encoder.c b/c_src/encoder.c index 5618da00..6f58cf0c 100644 --- a/c_src/encoder.c +++ b/c_src/encoder.c @@ -568,6 +568,49 @@ enc_map_to_ejson(ErlNifEnv* env, ERL_NIF_TERM map, ERL_NIF_TERM* out) } #endif +ERL_NIF_TERM +enc_object_element(Encoder* e, int first, ERL_NIF_TERM curr, ERL_NIF_TERM* stackp) +{ + ErlNifEnv* env = e->env; + ERL_NIF_TERM stack = *stackp; + ERL_NIF_TERM item; + const ERL_NIF_TERM* tuple; + int arity; + + if(first && !enc_start_object(e)) { + return enc_error(e, "internal_error"); + } + if(enif_is_empty_list(env, curr)) { + if(!enc_end_object(e)) { + return enc_error(e, "internal_error"); + } + return 0; + } + if(!enif_get_list_cell(env, curr, &item, &curr)) { + return enc_error(e, "internal_error"); + } + if(!enif_get_tuple(env, item, &arity, &tuple)) { + return enc_obj_error(e, "invalid_object_member", item); + } + if(arity != 2) { + return enc_obj_error(e, "invalid_object_member_arity", item); + } + if(!first && !enc_comma(e)) { + return enc_error(e, "internal_error"); + } + if(!enc_string(e, tuple[0])) { + return enc_obj_error(e, "invalid_object_member_key", tuple[0]); + } + if(!enc_colon(e)) { + return enc_error(e, "internal_error"); + } + stack = enif_make_list_cell(env, curr, stack); + stack = enif_make_list_cell(env, e->atoms->ref_object, stack); + stack = enif_make_list_cell(env, tuple[1], stack); + *stackp = stack; + return 0; +} + ERL_NIF_TERM encode_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { @@ -682,40 +725,8 @@ encode_iter(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) ret = enc_error(e, "internal_error"); goto done; } - if(enif_is_empty_list(env, curr)) { - if(!enc_end_object(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - continue; - } - if(!enif_get_list_cell(env, curr, &item, &curr)) { - ret = enc_error(e, "internal_error"); - goto done; - } - if(!enif_get_tuple(env, item, &arity, &tuple)) { - ret = enc_obj_error(e, "invalid_object_member", item); - goto done; - } - if(arity != 2) { - ret = enc_obj_error(e, "invalid_object_member_arity", item); - goto done; - } - if(!enc_comma(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - if(!enc_string(e, tuple[0])) { - ret = enc_obj_error(e, "invalid_object_member_key", tuple[0]); - goto done; - } - if(!enc_colon(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - stack = enif_make_list_cell(env, curr, stack); - stack = enif_make_list_cell(env, e->atoms->ref_object, stack); - stack = enif_make_list_cell(env, tuple[1], stack); + ret = enc_object_element(e, 0, curr, &stack); + if(ret) { goto done; } } else if(enif_is_identical(curr, e->atoms->ref_array)) { if(!enif_get_list_cell(env, stack, &curr, &stack)) { ret = enc_error(e, "internal_error"); @@ -791,40 +802,8 @@ encode_iter(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) ret = enc_obj_error(e, "invalid_object", curr); goto done; } - if(!enc_start_object(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - if(enif_is_empty_list(env, tuple[0])) { - if(!enc_end_object(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - continue; - } - if(!enif_get_list_cell(env, tuple[0], &item, &curr)) { - ret = enc_error(e, "internal_error"); - goto done; - } - if(!enif_get_tuple(env, item, &arity, &tuple)) { - ret = enc_obj_error(e, "invalid_object_member", item); - goto done; - } - if(arity != 2) { - ret = enc_obj_error(e, "invalid_object_member_arity", item); - goto done; - } - if(!enc_string(e, tuple[0])) { - ret = enc_obj_error(e, "invalid_object_member_key", tuple[0]); - goto done; - } - if(!enc_colon(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - stack = enif_make_list_cell(env, curr, stack); - stack = enif_make_list_cell(env, e->atoms->ref_object, stack); - stack = enif_make_list_cell(env, tuple[1], stack); + ret = enc_object_element(e, 1, tuple[0], &stack); + if (ret) { goto done; } #if MAP_TYPE_PRESENT } else if(enif_is_map(env, curr)) { if(!enc_map_to_ejson(env, curr, &curr)) { From bbcfc12e1fd738c0f7b7a76fcbce5cb2ef17cd9b Mon Sep 17 00:00:00 2001 From: David Hull Date: Mon, 15 Oct 2018 21:49:19 +0000 Subject: [PATCH 4/5] Refactor common array element encoding to new function enc_array_element. --- c_src/encoder.c | 69 +++++++++++++++++++++++-------------------------- 1 file changed, 33 insertions(+), 36 deletions(-) diff --git a/c_src/encoder.c b/c_src/encoder.c index 6f58cf0c..2b67273e 100644 --- a/c_src/encoder.c +++ b/c_src/encoder.c @@ -611,6 +611,35 @@ enc_object_element(Encoder* e, int first, ERL_NIF_TERM curr, ERL_NIF_TERM* stack return 0; } +ERL_NIF_TERM +enc_array_element(Encoder* e, int first, ERL_NIF_TERM curr, ERL_NIF_TERM* stackp) +{ + ErlNifEnv* env = e->env; + ERL_NIF_TERM stack = *stackp; + ERL_NIF_TERM item; + + if(first && !enc_start_array(e)) { + return enc_error(e, "internal_error"); + } + if(enif_is_empty_list(env, curr)) { + if(!enc_end_array(e)) { + return enc_error(e, "internal_error"); + } + return 0; + } + if(!enif_get_list_cell(env, curr, &item, &curr)) { + return enc_error(e, "internal_error"); + } + if(!first && !enc_comma(e)) { + return enc_error(e, "internal_error"); + } + stack = enif_make_list_cell(env, curr, stack); + stack = enif_make_list_cell(env, e->atoms->ref_array, stack); + stack = enif_make_list_cell(env, item, stack); + *stackp = stack; + return 0; +} + ERL_NIF_TERM encode_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { @@ -732,24 +761,8 @@ encode_iter(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) ret = enc_error(e, "internal_error"); goto done; } - if(enif_is_empty_list(env, curr)) { - if(!enc_end_array(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - continue; - } - if(!enc_comma(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - if(!enif_get_list_cell(env, curr, &item, &curr)) { - ret = enc_error(e, "internal_error"); - goto done; - } - stack = enif_make_list_cell(env, curr, stack); - stack = enif_make_list_cell(env, e->atoms->ref_array, stack); - stack = enif_make_list_cell(env, item, stack); + ret = enc_array_element(e, 0, curr, &stack); + if(ret) { goto done; } } else if(enif_compare(curr, e->atoms->atom_null) == 0) { if(!enc_literal(e, "null", 4)) { ret = enc_error(e, "null"); @@ -813,24 +826,8 @@ encode_iter(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) stack = enif_make_list_cell(env, curr, stack); #endif } else if(enif_is_list(env, curr)) { - if(!enc_start_array(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - if(enif_is_empty_list(env, curr)) { - if(!enc_end_array(e)) { - ret = enc_error(e, "internal_error"); - goto done; - } - continue; - } - if(!enif_get_list_cell(env, curr, &item, &curr)) { - ret = enc_error(e, "internal_error"); - goto done; - } - stack = enif_make_list_cell(env, curr, stack); - stack = enif_make_list_cell(env, e->atoms->ref_array, stack); - stack = enif_make_list_cell(env, item, stack); + ret = enc_array_element(e, 1, curr, &stack); + if(ret) { goto done; } } else { if(!enc_unknown(e, curr)) { ret = enc_error(e, "internal_error"); From d3ce6e7ed6bb6a615183722dc2038aa76a6e639d Mon Sep 17 00:00:00 2001 From: David Hull Date: Thu, 16 Mar 2017 16:35:46 +0000 Subject: [PATCH 5/5] Add jiffy:partial_encode/2 function. --- c_src/encoder.c | 36 ++++++++++++++++++++++++ c_src/jiffy.c | 2 ++ c_src/jiffy.h | 2 ++ src/jiffy.erl | 21 +++++++++++--- test/jiffy_18_preencode_tests.erl | 46 ++++++++++++++++++++++++++++++- 5 files changed, 102 insertions(+), 5 deletions(-) diff --git a/c_src/encoder.c b/c_src/encoder.c index 2b67273e..fcacf81b 100644 --- a/c_src/encoder.c +++ b/c_src/encoder.c @@ -580,6 +580,7 @@ enc_object_element(Encoder* e, int first, ERL_NIF_TERM curr, ERL_NIF_TERM* stack if(first && !enc_start_object(e)) { return enc_error(e, "internal_error"); } +next_object_elt: if(enif_is_empty_list(env, curr)) { if(!enc_end_object(e)) { return enc_error(e, "internal_error"); @@ -595,6 +596,22 @@ enc_object_element(Encoder* e, int first, ERL_NIF_TERM curr, ERL_NIF_TERM* stack if(arity != 2) { return enc_obj_error(e, "invalid_object_member_arity", item); } + if(enif_compare(tuple[0], e->atoms->atom_partial_object) == 0) { + ErlNifBinary bin; + if(!enif_inspect_binary(env, tuple[1], &bin)) { + return enc_error(e, "internal_error"); + } + if(bin.size > 0) { + if(!first && !enc_comma(e)) { + return enc_error(e, "internal_error"); + } + if(!enc_unknown(e, tuple[1])) { + return enc_error(e, "internal_error"); + } + first = 0; + } + goto next_object_elt; + } if(!first && !enc_comma(e)) { return enc_error(e, "internal_error"); } @@ -617,10 +634,14 @@ enc_array_element(Encoder* e, int first, ERL_NIF_TERM curr, ERL_NIF_TERM* stackp ErlNifEnv* env = e->env; ERL_NIF_TERM stack = *stackp; ERL_NIF_TERM item; + const ERL_NIF_TERM* tuple; + int arity; + ErlNifBinary bin; if(first && !enc_start_array(e)) { return enc_error(e, "internal_error"); } +next_array_elt: if(enif_is_empty_list(env, curr)) { if(!enc_end_array(e)) { return enc_error(e, "internal_error"); @@ -630,6 +651,21 @@ enc_array_element(Encoder* e, int first, ERL_NIF_TERM curr, ERL_NIF_TERM* stackp if(!enif_get_list_cell(env, curr, &item, &curr)) { return enc_error(e, "internal_error"); } + if(enif_get_tuple(env, item, &arity, &tuple) && + (arity == 2) && + (enif_compare(tuple[0], e->atoms->atom_partial_array) == 0) && + enif_inspect_binary(env, tuple[1], &bin)) { + if (bin.size > 0) { + if(!first && !enc_comma(e)) { + return enc_error(e, "internal_error"); + } + if(!enc_unknown(e, tuple[1])) { + return enc_error(e, "internal_error"); + } + first = 0; + } + goto next_array_elt; + } if(!first && !enc_comma(e)) { return enc_error(e, "internal_error"); } diff --git a/c_src/jiffy.c b/c_src/jiffy.c index 03ded3ed..1178aafa 100644 --- a/c_src/jiffy.c +++ b/c_src/jiffy.c @@ -16,6 +16,8 @@ load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info) st->atom_null = make_atom(env, "null"); st->atom_true = make_atom(env, "true"); st->atom_false = make_atom(env, "false"); + st->atom_partial_object = make_atom(env, "$partial_object$"); + st->atom_partial_array = make_atom(env, "$partial_array$"); st->atom_bignum = make_atom(env, "bignum"); st->atom_bignum_e = make_atom(env, "bignum_e"); st->atom_bigdbl = make_atom(env, "bigdbl"); diff --git a/c_src/jiffy.h b/c_src/jiffy.h index ef03a06c..d78a7ff9 100644 --- a/c_src/jiffy.h +++ b/c_src/jiffy.h @@ -19,6 +19,8 @@ typedef struct { ERL_NIF_TERM atom_null; ERL_NIF_TERM atom_true; ERL_NIF_TERM atom_false; + ERL_NIF_TERM atom_partial_object; + ERL_NIF_TERM atom_partial_array; ERL_NIF_TERM atom_bignum; ERL_NIF_TERM atom_bignum_e; ERL_NIF_TERM atom_bigdbl; diff --git a/src/jiffy.erl b/src/jiffy.erl index 88c19254..c807ef80 100644 --- a/src/jiffy.erl +++ b/src/jiffy.erl @@ -2,7 +2,7 @@ % See the LICENSE file for more information. -module(jiffy). --export([decode/1, decode/2, encode/1, encode/2]). +-export([decode/1, decode/2, encode/1, encode/2, partial_encode/2]). -define(NOT_LOADED, not_loaded(?LINE)). -compile([no_native]). @@ -19,17 +19,20 @@ | json_array() | json_preencoded(). --type json_array() :: [json_value()]. +-type json_array() :: [json_value()|json_partial_array()]. -type json_string() :: atom() | binary(). -type json_number() :: integer() | float(). +-type json_partial_array() :: {'$partial_array$', iodata()}. +-type json_partial_object() :: {'$partial_object$', iodata()}. + -ifdef(JIFFY_NO_MAPS). --type json_object() :: {[{json_string(),json_value()}]}. +-type json_object() :: {[({json_string(),json_value()})|json_partial_object()]}. -else. --type json_object() :: {[{json_string(),json_value()}]} +-type json_object() :: {[({json_string(),json_value()})|json_partial_object()]} | #{json_string() => json_value()}. -endif. @@ -109,6 +112,16 @@ encode(Data, Options) -> end. +-spec partial_encode(json_array(), encode_options()) -> json_partial_array(); + (json_object(), encode_options()) -> json_partial_object(). +partial_encode(Data, Options) when is_list(Data) -> + Json = iolist_to_binary(encode(Data, Options)), + {'$partial_array$', binary_part(Json, 1, byte_size(Json) - 2)}; +partial_encode(Data, Options) when is_tuple(Data) -> + Json = iolist_to_binary(encode(Data, Options)), + {'$partial_object$', binary_part(Json, 1, byte_size(Json) - 2)}. + + finish_decode({bignum, Value}) -> list_to_integer(binary_to_list(Value)); finish_decode({bignum_e, Value}) -> diff --git a/test/jiffy_18_preencode_tests.erl b/test/jiffy_18_preencode_tests.erl index 5bc36bf4..950c7260 100644 --- a/test/jiffy_18_preencode_tests.erl +++ b/test/jiffy_18_preencode_tests.erl @@ -17,6 +17,11 @@ gen(ok, {E1, J, E2}) -> {msg("~p", [E1]), [ {"Encode", ?_assertEqual(J, enc(E1))}, {"Decode", ?_assertEqual(E2, dec(J))} + ]}; + +gen(ok, {E, J}) -> + {msg("~p", [E]), [ + {"Encode", ?_assertEqual(J, enc(E))} ]}. %% gen(error, E) -> @@ -45,7 +50,46 @@ cases(ok) -> , { [ {json, JSON}, {json, JSON} ], <<"[[1,\"a\"],[1,\"a\"]]">>, [ EJSON, EJSON ]} , { {[ {<<"a">>, {json, JSON}} ]}, <<"{\"a\":[1,\"a\"]}">>, {[ {<<"a">>, EJSON} ]}} ], - TopTests ++ BuriedTests. + + PartialArray1 = jiffy:partial_encode([ 2, 3 ], []), + PartialArray2 = jiffy:partial_encode([], []), + PartialArray3 = jiffy:partial_encode([ 5 ], []), + PartialArrayTests = + [ {[ PartialArray1 ], <<"[2,3]">>} + , {[ 1, PartialArray1 ], <<"[1,2,3]">>} + , {[ PartialArray1, 4 ], <<"[2,3,4]">>} + , {[ 1, PartialArray1, 4 ], <<"[1,2,3,4]">>} + , {[ PartialArray2 ], <<"[]">>} + , {[ 1, PartialArray2 ], <<"[1]">>} + , {[ PartialArray2, 4 ], <<"[4]">>} + , {[ 1, PartialArray2, 4 ], <<"[1,4]">>} + , {[ PartialArray1, PartialArray2 ], <<"[2,3]">>} + , {[ PartialArray2, PartialArray1 ], <<"[2,3]">>} + , {[ PartialArray1, PartialArray1 ], <<"[2,3,2,3]">>} + , {[ PartialArray2, PartialArray2 ], <<"[]">>} + , {[ PartialArray1, PartialArray3 ], <<"[2,3,5]">>} + , {[ 1, PartialArray1, 4, PartialArray3, 6 ], <<"[1,2,3,4,5,6]">>} + ], + + PartialObject1 = jiffy:partial_encode({[ {<<"ii">>, <<"two">>}, {<<"iii">>, 3} ]}, []), + PartialObject2 = jiffy:partial_encode({[]}, []), + PartialObject3 = jiffy:partial_encode({[ {<<"v">>, [ 1, 2, 3, 4, 5 ]} ]}, []), + PartialObjectTests = + [ {{[ PartialObject1 ]}, <<"{\"ii\":\"two\",\"iii\":3}">>} + , {{[ {<<"i">>, 1}, PartialObject1 ]}, <<"{\"i\":1,\"ii\":\"two\",\"iii\":3}">>} + , {{[ PartialObject1, {<<"iv">>, 4} ]}, <<"{\"ii\":\"two\",\"iii\":3,\"iv\":4}">>} + , {{[ {<<"i">>, 1}, PartialObject1, {<<"iv">>, 4} ]}, <<"{\"i\":1,\"ii\":\"two\",\"iii\":3,\"iv\":4}">>} + , {{[ PartialObject2 ]}, <<"{}">>} + , {{[ {<<"i">>, 1}, PartialObject2 ]}, <<"{\"i\":1}">>} + , {{[ PartialObject2, {<<"iv">>, 4} ]}, <<"{\"iv\":4}">>} + , {{[ {<<"i">>, 1}, PartialObject2, {<<"iv">>, 4} ]}, <<"{\"i\":1,\"iv\":4}">>} + , {{[ PartialObject1, PartialObject2 ]}, <<"{\"ii\":\"two\",\"iii\":3}">>} + , {{[ PartialObject2, PartialObject1 ]}, <<"{\"ii\":\"two\",\"iii\":3}">>} + , {{[ PartialObject2, PartialObject2 ]}, <<"{}">>} + , {{[ PartialObject1, PartialObject3 ]}, <<"{\"ii\":\"two\",\"iii\":3,\"v\":[1,2,3,4,5]}">>} + ], + + TopTests ++ BuriedTests ++ PartialArrayTests ++ PartialObjectTests. %% cases(error) -> %% [ {json, true}