diff --git a/src/jsx_encoder.erl b/src/jsx_encoder.erl index f4d83e7..0af674c 100644 --- a/src/jsx_encoder.erl +++ b/src/jsx_encoder.erl @@ -118,49 +118,48 @@ encode(Term) -> (encoder(jsx, [], []))(Term). encode_test_() -> [ - {"naked string", ?_assert(encode(<<"a string">>) - =:= [{string, <<"a string">>}, end_json]) - }, - {"naked integer", ?_assert(encode(123) - =:= [{integer, 123}, end_json]) - }, - {"naked float", ?_assert(encode(1.23) - =:= [{float, 1.23}, end_json]) - }, - {"naked literal", ?_assert(encode(null) - =:= [{literal, null}, end_json]) - }, - {"empty object", ?_assert(encode([{}]) - =:= [start_object, end_object, end_json]) - }, - {"empty list", ?_assert(encode([]) - =:= [start_array, end_array, end_json]) - }, - {"simple list", ?_assert(encode([1,2,3,true,false]) - =:= [start_array, + {"naked string", ?_assertEqual(encode(<<"a string">>), [{string, <<"a string">>}, end_json])}, + {"naked integer", ?_assertEqual(encode(123), [{integer, 123}, end_json])}, + {"naked float", ?_assertEqual(encode(1.23), [{float, 1.23}, end_json])}, + {"naked literal", ?_assertEqual(encode(null), [{literal, null}, end_json])}, + {"empty object", ?_assertEqual(encode([{}]), [start_object, end_object, end_json])}, + {"empty list", ?_assertEqual(encode([]), [start_array, end_array, end_json])}, + {"simple list", ?_assertEqual( + encode([1,2,3,true,false]), + [ + start_array, {integer, 1}, {integer, 2}, {integer, 3}, {literal, true}, {literal, false}, end_array, - end_json]) + end_json + ] + ) }, - {"simple object", ?_assert(encode([{<<"a">>, true}, {<<"b">>, false}]) - =:= [start_object, + {"simple object", ?_assertEqual( + encode([{<<"a">>, true}, {<<"b">>, false}]), + [ + start_object, {key, <<"a">>}, {literal, true}, {key, <<"b">>}, {literal, false}, end_object, - end_json]) + end_json + ] + ) }, - {"complex term", ?_assert(encode([ - {<<"a">>, true}, - {<<"b">>, false}, - {<<"c">>, [1,2,3]}, - {<<"d">>, [{<<"key">>, <<"value">>}]} - ]) =:= [start_object, + {"complex term", ?_assertEqual( + encode([ + {<<"a">>, true}, + {<<"b">>, false}, + {<<"c">>, [1,2,3]}, + {<<"d">>, [{<<"key">>, <<"value">>}]} + ]), + [ + start_object, {key, <<"a">>}, {literal, true}, {key, <<"b">>}, @@ -177,14 +176,14 @@ encode_test_() -> {string, <<"value">>}, end_object, end_object, - end_json]) + end_json + ] + ) }, - {"atom keys", ?_assert(encode([{key, <<"value">>}]) - =:= [start_object, - {key, <<"key">>}, - {string, <<"value">>}, - end_object, - end_json]) + {"atom keys", ?_assertEqual( + encode([{key, <<"value">>}]), + [start_object, {key, <<"key">>}, {string, <<"value">>}, end_object, end_json] + ) } ]. diff --git a/src/jsx_to_json.erl b/src/jsx_to_json.erl index 6d012f5..0e4edf4 100644 --- a/src/jsx_to_json.erl +++ b/src/jsx_to_json.erl @@ -186,176 +186,148 @@ teardown_nicedecimal_meck(_) -> basic_format_test_() -> [ - {"empty object", ?_assert(format(<<"{}">>, []) =:= <<"{}">>)}, - {"empty array", ?_assert(format(<<"[]">>, []) =:= <<"[]">>)}, - {"naked integer", ?_assert(format(<<"123">>, []) =:= <<"123">>)}, + {"empty object", ?_assertEqual(format(<<"{}">>, []), <<"{}">>)}, + {"empty array", ?_assertEqual(format(<<"[]">>, []), <<"[]">>)}, + {"naked integer", ?_assertEqual(format(<<"123">>, []), <<"123">>)}, {foreach, fun() -> setup_nicedecimal_meck(<<"1.23">>) end, fun(R) -> teardown_nicedecimal_meck(R) end, - [{"naked float", ?_assert(format(<<"1.23">>, []) =:= <<"1.23">>)}] - }, - {"naked string", ?_assert(format(<<"\"hi\"">>, []) =:= <<"\"hi\"">>)}, - {"naked literal", ?_assert(format(<<"true">>, []) =:= <<"true">>)}, - {"simple object", - ?_assert(format(<<" { \"key\" :\n\t \"value\"\r\r\r\n } ">>, - [] - ) =:= <<"{\"key\":\"value\"}">> - ) - }, - {"really simple object", - ?_assert(format(<<"{\"k\":\"v\"}">>, []) =:= <<"{\"k\":\"v\"}">>) - }, - {"nested object", - ?_assert(format(<<"{\"k\":{\"k\":\"v\"}, \"j\":{}}">>, [] - ) =:= <<"{\"k\":{\"k\":\"v\"},\"j\":{}}">> - ) - }, - {"simple array", - ?_assert(format(<<" [\n\ttrue,\n\tfalse , \n \tnull\n] ">>, - [] - ) =:= <<"[true,false,null]">> - ) - }, - {"really simple array", ?_assert(format(<<"[1]">>, []) =:= <<"[1]">>)}, - {"nested array", ?_assert(format(<<"[[[]]]">>, []) =:= <<"[[[]]]">>)}, - {"nested structures", - ?_assert(format( - <<"[{\"key\":\"value\", - \"another key\": \"another value\", - \"a list\": [true, false] - }, - [[{}]] - ]">>, [] - ) =:= <<"[{\"key\":\"value\",\"another key\":\"another value\",\"a list\":[true,false]},[[{}]]]">> - ) + [{"naked float", ?_assertEqual(format(<<"1.23">>, []), <<"1.23">>)}] }, + {"naked string", ?_assertEqual(format(<<"\"hi\"">>, []), <<"\"hi\"">>)}, + {"naked literal", ?_assertEqual(format(<<"true">>, []), <<"true">>)}, + {"simple object", ?_assertEqual( + format(<<" { \"key\" :\n\t \"value\"\r\r\r\n } ">>, []), + <<"{\"key\":\"value\"}">> + )}, + {"really simple object", ?_assertEqual(format(<<"{\"k\":\"v\"}">>, []) , <<"{\"k\":\"v\"}">>)}, + {"nested object", ?_assertEqual( + format(<<"{\"k\":{\"k\":\"v\"}, \"j\":{}}">>, []), + <<"{\"k\":{\"k\":\"v\"},\"j\":{}}">> + )}, + {"simple array", ?_assertEqual( + format(<<" [\n\ttrue,\n\tfalse , \n \tnull\n] ">>, []), + <<"[true,false,null]">> + )}, + {"really simple array", ?_assertEqual(format(<<"[1]">>, []), <<"[1]">>)}, + {"nested array", ?_assertEqual(format(<<"[[[]]]">>, []), <<"[[[]]]">>)}, + {"nested structures", ?_assertEqual( + format(<<"[ + { + \"key\":\"value\", + \"another key\": \"another value\", + \"a list\": [true, false] + }, + [[{}]] + ]">>, []), + <<"[{\"key\":\"value\",\"another key\":\"another value\",\"a list\":[true,false]},[[{}]]]">> + )}, {"simple nested structure", - ?_assert(format(<<"[[],{\"k\":[[],{}],\"j\":{}},[]]">>, [] - ) =:= <<"[[],{\"k\":[[],{}],\"j\":{}},[]]">> + ?_assertEqual( + format(<<"[[],{\"k\":[[],{}],\"j\":{}},[]]">>, []), + <<"[[],{\"k\":[[],{}],\"j\":{}},[]]">> ) } ]. basic_to_json_test_() -> [ - {"empty object", ?_assert(to_json([{}], []) =:= <<"{}">>)}, - {"empty array", ?_assert(to_json([], []) =:= <<"[]">>)}, - {"naked integer", ?_assert(to_json(123, []) =:= <<"123">>)}, + {"empty object", ?_assertEqual(to_json([{}], []), <<"{}">>)}, + {"empty array", ?_assertEqual(to_json([], []), <<"[]">>)}, + {"naked integer", ?_assertEqual(to_json(123, []), <<"123">>)}, {foreach, fun() -> setup_nicedecimal_meck(<<"1.23">>) end, fun(R) -> teardown_nicedecimal_meck(R) end, - [{"naked float", ?_assert(to_json(1.23, []) =:= <<"1.23">>)}] + [{"naked float", ?_assertEqual(to_json(1.23, []) , <<"1.23">>)}] }, - {"naked string", ?_assert(to_json(<<"hi">>, []) =:= <<"\"hi\"">>)}, - {"naked literal", ?_assert(to_json(true, []) =:= <<"true">>)}, - {"simple object", - ?_assert(to_json( - [{<<"key">>, <<"value">>}], - [] - ) =:= <<"{\"key\":\"value\"}">> - ) - }, - {"nested object", - ?_assert(to_json( - [{<<"k">>,[{<<"k">>,<<"v">>}]},{<<"j">>,[{}]}], - [] - ) =:= <<"{\"k\":{\"k\":\"v\"},\"j\":{}}">> - ) - }, - {"simple array", - ?_assert(to_json( - [true, false, null], - [] - ) =:= <<"[true,false,null]">> - ) - }, - {"really simple array", ?_assert(to_json([1], []) =:= <<"[1]">>)}, - {"nested array", ?_assert(to_json([[[]]], []) =:= <<"[[[]]]">>)}, - {"nested structures", - ?_assert(to_json( + {"naked string", ?_assertEqual(to_json(<<"hi">>, []), <<"\"hi\"">>)}, + {"naked literal", ?_assertEqual(to_json(true, []), <<"true">>)}, + {"simple object", ?_assertEqual( + to_json( + [{<<"key">>, <<"value">>}], + [] + ), + <<"{\"key\":\"value\"}">> + )}, + {"nested object", ?_assertEqual( + to_json( + [{<<"k">>,[{<<"k">>,<<"v">>}]},{<<"j">>,[{}]}], + [] + ), + <<"{\"k\":{\"k\":\"v\"},\"j\":{}}">> + )}, + {"simple array", ?_assertEqual(to_json([true, false, null], []), <<"[true,false,null]">>)}, + {"really simple array", ?_assertEqual(to_json([1], []), <<"[1]">>)}, + {"nested array", ?_assertEqual(to_json([[[]]], []), <<"[[[]]]">>)}, + {"nested structures", ?_assertEqual( + to_json( + [ [ - [ - {<<"key">>, <<"value">>}, - {<<"another key">>, <<"another value">>}, - {<<"a list">>, [true, false]} - ], - [[[{}]]] + {<<"key">>, <<"value">>}, + {<<"another key">>, <<"another value">>}, + {<<"a list">>, [true, false]} ], - [] - ) =:= <<"[{\"key\":\"value\",\"another key\":\"another value\",\"a list\":[true,false]},[[{}]]]">> - ) - }, - {"simple nested structure", - ?_assert(to_json( - [[], [{<<"k">>, [[], [{}]]}, {<<"j">>, [{}]}], []], - [] - ) =:= <<"[[],{\"k\":[[],{}],\"j\":{}},[]]">> - ) - } + [[[{}]]] + ], + [] + ), + <<"[{\"key\":\"value\",\"another key\":\"another value\",\"a list\":[true,false]},[[{}]]]">> + )}, + {"simple nested structure", ?_assertEqual( + to_json( + [[], [{<<"k">>, [[], [{}]]}, {<<"j">>, [{}]}], []], + [] + ), + <<"[[],{\"k\":[[],{}],\"j\":{}},[]]">> + )} ]. opts_test_() -> [ - {"unspecified indent/space", - ?_assert(format(<<" [\n\ttrue,\n\tfalse,\n\tnull\n] ">>, - [space, indent] - ) =:= <<"[\n true,\n false,\n null\n]">> - ) - }, - {"specific indent/space", - ?_assert(format( - <<"\n{\n\"key\" : [],\n\"another key\" : true\n}\n">>, - [{space, 2}, {indent, 3}] - ) =:= <<"{\n \"key\": [],\n \"another key\": true\n}">> - ) - }, - {"nested structures", - ?_assert(format( - <<"[{\"key\":\"value\", - \"another key\": \"another value\" - }, - [[true, false, null]] - ]">>, - [{space, 2}, {indent, 2}] - ) =:= <<"[\n {\n \"key\": \"value\",\n \"another key\": \"another value\"\n },\n [\n [\n true,\n false,\n null\n ]\n ]\n]">> - ) - }, - {"array spaces", - ?_assert(format(<<"[1,2,3]">>, - [{space, 2}] - ) =:= <<"[1, 2, 3]">> - ) - }, - {"object spaces", - ?_assert(format(<<"{\"a\":true,\"b\":true,\"c\":true}">>, - [{space, 2}] - ) =:= <<"{\"a\": true, \"b\": true, \"c\": true}">> - ) - }, + {"unspecified indent/space", ?_assertEqual( + format(<<" [\n\ttrue,\n\tfalse,\n\tnull\n] ">>, [space, indent]), + <<"[\n true,\n false,\n null\n]">> + )}, + {"specific indent/space", ?_assertEqual( + format( + <<"\n{\n\"key\" : [],\n\"another key\" : true\n}\n">>, + [{space, 2}, {indent, 3}] + ), + <<"{\n \"key\": [],\n \"another key\": true\n}">> + )}, + {"nested structures", ?_assertEqual( + format( + <<"[{\"key\":\"value\", \"another key\": \"another value\"}, [[true, false, null]]]">>, + [{space, 2}, {indent, 2}] + ), + <<"[\n {\n \"key\": \"value\",\n \"another key\": \"another value\"\n },\n [\n [\n true,\n false,\n null\n ]\n ]\n]">> + )}, + {"array spaces", ?_assertEqual( + format(<<"[1,2,3]">>, [{space, 2}]), + <<"[1, 2, 3]">> + )}, + {"object spaces", ?_assertEqual( + format(<<"{\"a\":true,\"b\":true,\"c\":true}">>, [{space, 2}]), + <<"{\"a\": true, \"b\": true, \"c\": true}">> + )}, {foreach, fun() -> setup_nicedecimal_meck(<<"1.23">>) end, fun(R) -> teardown_nicedecimal_meck(R) end, - [{ - "array indent", - ?_assert(format(<<"[1.23, 1.23, 1.23]">>, - [{indent, 2}] - ) =:= <<"[\n 1.23,\n 1.23,\n 1.23\n]">> - ) - }] + [{"array indent", ?_assertEqual( + format(<<"[1.23, 1.23, 1.23]">>, [{indent, 2}]), + <<"[\n 1.23,\n 1.23,\n 1.23\n]">> + )}] }, - {"object indent", - ?_assert(format(<<"{\"a\":true,\"b\":true,\"c\":true}">>, - [{indent, 2}] - ) =:= <<"{\n \"a\":true,\n \"b\":true,\n \"c\":true\n}">> - ) - } + {"object indent", ?_assertEqual( + format(<<"{\"a\":true,\"b\":true,\"c\":true}">>, [{indent, 2}]), + <<"{\n \"a\":true,\n \"b\":true,\n \"c\":true\n}">> + )} ]. ext_opts_test_() -> - [{"extopts", ?_assert(format(<<"[]">>, - [loose_unicode, {escape_forward_slash, true}] - ) =:= <<"[]">> - )} - ]. + [{"extopts", ?_assertEqual( + format(<<"[]">>, [loose_unicode, {escape_forward_slash, true}]), + <<"[]">> + )}]. -endif. \ No newline at end of file diff --git a/src/jsx_to_term.erl b/src/jsx_to_term.erl index 3099829..b5b73bc 100644 --- a/src/jsx_to_term.erl +++ b/src/jsx_to_term.erl @@ -102,35 +102,29 @@ format_key(Key, Opts) -> basic_test_() -> [ - {"empty object", ?_assert(to_term(<<"{}">>, []) =:= [{}])}, - {"simple object", ?_assert(to_term(<<"{\"key\": true}">>, []) =:= [{<<"key">>, true}])}, - {"less simple object", - ?_assert(to_term(<<"{\"a\": 1, \"b\": 2}">>, []) =:= [{<<"a">>, 1}, {<<"b">>, 2}]) - }, - {"nested object", - ?_assert(to_term(<<"{\"key\": {\"key\": true}}">>, []) =:= [{<<"key">>, [{<<"key">>, true}]}]) - }, + {"empty object", ?_assertEqual(to_term(<<"{}">>, []), [{}])}, + {"simple object", ?_assertEqual(to_term(<<"{\"key\": true}">>, []), [{<<"key">>, true}])}, + {"less simple object", ?_assertEqual( + to_term(<<"{\"a\": 1, \"b\": 2}">>, []), + [{<<"a">>, 1}, {<<"b">>, 2}] + )}, + {"nested object", ?_assertEqual( + to_term(<<"{\"key\": {\"key\": true}}">>, []), + [{<<"key">>, [{<<"key">>, true}]}] + )}, {"empty array", ?_assert(to_term(<<"[]">>, []) =:= [])}, - {"list of lists", - ?_assert(to_term(<<"[[],[],[]]">>, []) =:= [[], [], []]) - }, - {"list of strings", - ?_assert(to_term(<<"[\"hi\", \"there\"]">>, []) =:= [<<"hi">>, <<"there">>]) - }, - {"list of numbers", - ?_assert(to_term(<<"[1, 2.0, 3e4, -5]">>, []) =:= [1, 2.0, 3.0e4, -5]) - }, - {"list of literals", - ?_assert(to_term(<<"[true,false,null]">>, []) =:= [true,false,null]) - }, - {"list of objects", - ?_assert(to_term(<<"[{}, {\"a\":1, \"b\":2}, {\"key\":[true,false]}]">>, []) - =:= [[{}], [{<<"a">>,1},{<<"b">>,2}], [{<<"key">>,[true,false]}]]) - } + {"list of lists", ?_assertEqual(to_term(<<"[[],[],[]]">>, []), [[], [], []])}, + {"list of strings", ?_assertEqual(to_term(<<"[\"hi\", \"there\"]">>, []), [<<"hi">>, <<"there">>])}, + {"list of numbers", ?_assertEqual(to_term(<<"[1, 2.0, 3e4, -5]">>, []), [1, 2.0, 3.0e4, -5])}, + {"list of literals", ?_assertEqual(to_term(<<"[true,false,null]">>, []), [true,false,null])}, + {"list of objects", ?_assertEqual( + to_term(<<"[{}, {\"a\":1, \"b\":2}, {\"key\":[true,false]}]">>, []), + [[{}], [{<<"a">>,1},{<<"b">>,2}], [{<<"key">>,[true,false]}]] + )} ]. comprehensive_test_() -> - {"comprehensive test", ?_assert(to_term(comp_json(), []) =:= comp_term())}. + {"comprehensive test", ?_assertEqual(to_term(comp_json(), []), comp_term())}. comp_json() -> <<"[ @@ -157,7 +151,7 @@ comp_term() -> ]. atom_labels_test_() -> - {"atom labels test", ?_assert(to_term(comp_json(), [{labels, atom}]) =:= atom_term())}. + {"atom labels test", ?_assertEqual(to_term(comp_json(), [{labels, atom}]), atom_term())}. atom_term() -> [ @@ -173,10 +167,10 @@ atom_term() -> naked_test_() -> [ - {"naked integer", ?_assert(to_term(<<"123">>, []) =:= 123)}, - {"naked float", ?_assert(to_term(<<"-4.32e-17">>, []) =:= -4.32e-17)}, - {"naked literal", ?_assert(to_term(<<"true">>, []) =:= true)}, - {"naked string", ?_assert(to_term(<<"\"string\"">>, []) =:= <<"string">>)} + {"naked integer", ?_assertEqual(to_term(<<"123">>, []), 123)}, + {"naked float", ?_assertEqual(to_term(<<"-4.32e-17">>, []), -4.32e-17)}, + {"naked literal", ?_assertEqual(to_term(<<"true">>, []), true)}, + {"naked string", ?_assertEqual(to_term(<<"\"string\"">>, []), <<"string">>)} ]. -endif. \ No newline at end of file diff --git a/src/jsx_verify.erl b/src/jsx_verify.erl index d49c90f..1a91b37 100644 --- a/src/jsx_verify.erl +++ b/src/jsx_verify.erl @@ -169,11 +169,7 @@ term_true_test_() -> {"empty array", ?_assert(is_term([], []))}, {"whitespace", ?_assert(is_term([ true ], []))}, {"nested terms", - ?_assert(is_term( - [[{x, [[{}], [{}], [{}]]}, {y, [{}]}], [{}], [[[]]]], - [] - ) - ) + ?_assert(is_term([[{x, [[{}], [{}], [{}]]}, {y, [{}]}], [{}], [[[]]]], [])) }, {"numbers", ?_assert(is_term([-1.0, -1, -0, 0, 1.0e-1, 1, 1.0, 1.0e1], []))