umgeher/jsx
0
Fork 0
Code Issues Pull requests Activity

remove all ?_assert and replace with ?_assertFoo's

Browse source
This commit is contained in:
alisdair sullivan 2012-03-16 15:34:57 -07:00
parent aef1f71690
commit d2950ab8c7
4 changed files with 176 additions and 215 deletions
Download patch file Download diff file Expand all files Collapse all files

73
src/jsx_encoder.erl
View file

@ -118,49 +118,48 @@ encode(Term) -> (encoder(jsx, [], []))(Term).
encode_test_() -> encode_test_() ->
[ [
{"naked string", ?_assert(encode(<<"a string">>) {"naked string", ?_assertEqual(encode(<<"a string">>), [{string, <<"a string">>}, end_json])},
=:= [{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 integer", ?_assert(encode(123) {"naked literal", ?_assertEqual(encode(null), [{literal, null}, end_json])},
=:= [{integer, 123}, end_json]) {"empty object", ?_assertEqual(encode([{}]), [start_object, end_object, end_json])},
}, {"empty list", ?_assertEqual(encode([]), [start_array, end_array, end_json])},
{"naked float", ?_assert(encode(1.23) {"simple list", ?_assertEqual(
=:= [{float, 1.23}, end_json]) encode([1,2,3,true,false]),
}, [
{"naked literal", ?_assert(encode(null) start_array,
=:= [{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,
{integer, 1}, {integer, 1},
{integer, 2}, {integer, 2},
{integer, 3}, {integer, 3},
{literal, true}, {literal, true},
{literal, false}, {literal, false},
end_array, end_array,
end_json]) end_json
]
)
}, },
{"simple object", ?_assert(encode([{<<"a">>, true}, {<<"b">>, false}]) {"simple object", ?_assertEqual(
=:= [start_object, encode([{<<"a">>, true}, {<<"b">>, false}]),
[
start_object,
{key, <<"a">>}, {key, <<"a">>},
{literal, true}, {literal, true},
{key, <<"b">>}, {key, <<"b">>},
{literal, false}, {literal, false},
end_object, end_object,
end_json]) end_json
]
)
}, },
{"complex term", ?_assert(encode([ {"complex term", ?_assertEqual(
{<<"a">>, true}, encode([
{<<"b">>, false}, {<<"a">>, true},
{<<"c">>, [1,2,3]}, {<<"b">>, false},
{<<"d">>, [{<<"key">>, <<"value">>}]} {<<"c">>, [1,2,3]},
]) =:= [start_object, {<<"d">>, [{<<"key">>, <<"value">>}]}
]),
[
start_object,
{key, <<"a">>}, {key, <<"a">>},
{literal, true}, {literal, true},
{key, <<"b">>}, {key, <<"b">>},
@ -177,14 +176,14 @@ encode_test_() ->
{string, <<"value">>}, {string, <<"value">>},
end_object, end_object,
end_object, end_object,
end_json]) end_json
]
)
}, },
{"atom keys", ?_assert(encode([{key, <<"value">>}]) {"atom keys", ?_assertEqual(
=:= [start_object, encode([{key, <<"value">>}]),
{key, <<"key">>}, [start_object, {key, <<"key">>}, {string, <<"value">>}, end_object, end_json]
{string, <<"value">>}, )
end_object,
end_json])
} }
]. ].

260
src/jsx_to_json.erl
View file

@ -186,176 +186,148 @@ teardown_nicedecimal_meck(_) ->
basic_format_test_() -> basic_format_test_() ->
[ [
{"empty object", ?_assert(format(<<"{}">>, []) =:= <<"{}">>)}, {"empty object", ?_assertEqual(format(<<"{}">>, []), <<"{}">>)},
{"empty array", ?_assert(format(<<"[]">>, []) =:= <<"[]">>)}, {"empty array", ?_assertEqual(format(<<"[]">>, []), <<"[]">>)},
{"naked integer", ?_assert(format(<<"123">>, []) =:= <<"123">>)}, {"naked integer", ?_assertEqual(format(<<"123">>, []), <<"123">>)},
{foreach, {foreach,
fun() -> setup_nicedecimal_meck(<<"1.23">>) end, fun() -> setup_nicedecimal_meck(<<"1.23">>) end,
fun(R) -> teardown_nicedecimal_meck(R) end, fun(R) -> teardown_nicedecimal_meck(R) end,
[{"naked float", ?_assert(format(<<"1.23">>, []) =:= <<"1.23">>)}] [{"naked float", ?_assertEqual(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 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", {"simple nested structure",
?_assert(format(<<"[[],{\"k\":[[],{}],\"j\":{}},[]]">>, [] ?_assertEqual(
) =:= <<"[[],{\"k\":[[],{}],\"j\":{}},[]]">> format(<<"[[],{\"k\":[[],{}],\"j\":{}},[]]">>, []),
<<"[[],{\"k\":[[],{}],\"j\":{}},[]]">>
) )
} }
]. ].
basic_to_json_test_() -> basic_to_json_test_() ->
[ [
{"empty object", ?_assert(to_json([{}], []) =:= <<"{}">>)}, {"empty object", ?_assertEqual(to_json([{}], []), <<"{}">>)},
{"empty array", ?_assert(to_json([], []) =:= <<"[]">>)}, {"empty array", ?_assertEqual(to_json([], []), <<"[]">>)},
{"naked integer", ?_assert(to_json(123, []) =:= <<"123">>)}, {"naked integer", ?_assertEqual(to_json(123, []), <<"123">>)},
{foreach, {foreach,
fun() -> setup_nicedecimal_meck(<<"1.23">>) end, fun() -> setup_nicedecimal_meck(<<"1.23">>) end,
fun(R) -> teardown_nicedecimal_meck(R) 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 string", ?_assertEqual(to_json(<<"hi">>, []), <<"\"hi\"">>)},
{"naked literal", ?_assert(to_json(true, []) =:= <<"true">>)}, {"naked literal", ?_assertEqual(to_json(true, []), <<"true">>)},
{"simple object", {"simple object", ?_assertEqual(
?_assert(to_json( to_json(
[{<<"key">>, <<"value">>}], [{<<"key">>, <<"value">>}],
[] []
) =:= <<"{\"key\":\"value\"}">> ),
) <<"{\"key\":\"value\"}">>
}, )},
{"nested object", {"nested object", ?_assertEqual(
?_assert(to_json( to_json(
[{<<"k">>,[{<<"k">>,<<"v">>}]},{<<"j">>,[{}]}], [{<<"k">>,[{<<"k">>,<<"v">>}]},{<<"j">>,[{}]}],
[] []
) =:= <<"{\"k\":{\"k\":\"v\"},\"j\":{}}">> ),
) <<"{\"k\":{\"k\":\"v\"},\"j\":{}}">>
}, )},
{"simple array", {"simple array", ?_assertEqual(to_json([true, false, null], []), <<"[true,false,null]">>)},
?_assert(to_json( {"really simple array", ?_assertEqual(to_json([1], []), <<"[1]">>)},
[true, false, null], {"nested array", ?_assertEqual(to_json([[[]]], []), <<"[[[]]]">>)},
[] {"nested structures", ?_assertEqual(
) =:= <<"[true,false,null]">> to_json(
) [
},
{"really simple array", ?_assert(to_json([1], []) =:= <<"[1]">>)},
{"nested array", ?_assert(to_json([[[]]], []) =:= <<"[[[]]]">>)},
{"nested structures",
?_assert(to_json(
[ [
[ {<<"key">>, <<"value">>},
{<<"key">>, <<"value">>}, {<<"another key">>, <<"another value">>},
{<<"another key">>, <<"another value">>}, {<<"a list">>, [true, false]}
{<<"a list">>, [true, false]}
],
[[[{}]]]
], ],
[] [[[{}]]]
) =:= <<"[{\"key\":\"value\",\"another key\":\"another value\",\"a list\":[true,false]},[[{}]]]">> ],
) []
}, ),
{"simple nested structure", <<"[{\"key\":\"value\",\"another key\":\"another value\",\"a list\":[true,false]},[[{}]]]">>
?_assert(to_json( )},
[[], [{<<"k">>, [[], [{}]]}, {<<"j">>, [{}]}], []], {"simple nested structure", ?_assertEqual(
[] to_json(
) =:= <<"[[],{\"k\":[[],{}],\"j\":{}},[]]">> [[], [{<<"k">>, [[], [{}]]}, {<<"j">>, [{}]}], []],
) []
} ),
<<"[[],{\"k\":[[],{}],\"j\":{}},[]]">>
)}
]. ].
opts_test_() -> opts_test_() ->
[ [
{"unspecified indent/space", {"unspecified indent/space", ?_assertEqual(
?_assert(format(<<" [\n\ttrue,\n\tfalse,\n\tnull\n] ">>, format(<<" [\n\ttrue,\n\tfalse,\n\tnull\n] ">>, [space, indent]),
[space, indent] <<"[\n true,\n false,\n null\n]">>
) =:= <<"[\n true,\n false,\n null\n]">> )},
) {"specific indent/space", ?_assertEqual(
}, format(
{"specific indent/space", <<"\n{\n\"key\" : [],\n\"another key\" : true\n}\n">>,
?_assert(format( [{space, 2}, {indent, 3}]
<<"\n{\n\"key\" : [],\n\"another key\" : true\n}\n">>, ),
[{space, 2}, {indent, 3}] <<"{\n \"key\": [],\n \"another key\": true\n}">>
) =:= <<"{\n \"key\": [],\n \"another key\": true\n}">> )},
) {"nested structures", ?_assertEqual(
}, format(
{"nested structures", <<"[{\"key\":\"value\", \"another key\": \"another value\"}, [[true, false, null]]]">>,
?_assert(format( [{space, 2}, {indent, 2}]
<<"[{\"key\":\"value\", ),
\"another key\": \"another value\" <<"[\n {\n \"key\": \"value\",\n \"another key\": \"another value\"\n },\n [\n [\n true,\n false,\n null\n ]\n ]\n]">>
}, )},
[[true, false, null]] {"array spaces", ?_assertEqual(
]">>, format(<<"[1,2,3]">>, [{space, 2}]),
[{space, 2}, {indent, 2}] <<"[1, 2, 3]">>
) =:= <<"[\n {\n \"key\": \"value\",\n \"another key\": \"another value\"\n },\n [\n [\n true,\n false,\n null\n ]\n ]\n]">> )},
) {"object spaces", ?_assertEqual(
}, format(<<"{\"a\":true,\"b\":true,\"c\":true}">>, [{space, 2}]),
{"array spaces", <<"{\"a\": true, \"b\": true, \"c\": true}">>
?_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}">>
)
},
{foreach, {foreach,
fun() -> setup_nicedecimal_meck(<<"1.23">>) end, fun() -> setup_nicedecimal_meck(<<"1.23">>) end,
fun(R) -> teardown_nicedecimal_meck(R) end, fun(R) -> teardown_nicedecimal_meck(R) end,
[{ [{"array indent", ?_assertEqual(
"array indent", format(<<"[1.23, 1.23, 1.23]">>, [{indent, 2}]),
?_assert(format(<<"[1.23, 1.23, 1.23]">>, <<"[\n 1.23,\n 1.23,\n 1.23\n]">>
[{indent, 2}] )}]
) =:= <<"[\n 1.23,\n 1.23,\n 1.23\n]">>
)
}]
}, },
{"object indent", {"object indent", ?_assertEqual(
?_assert(format(<<"{\"a\":true,\"b\":true,\"c\":true}">>, format(<<"{\"a\":true,\"b\":true,\"c\":true}">>, [{indent, 2}]),
[{indent, 2}] <<"{\n \"a\":true,\n \"b\":true,\n \"c\":true\n}">>
) =:= <<"{\n \"a\":true,\n \"b\":true,\n \"c\":true\n}">>
)
}
].
ext_opts_test_() ->
[{"extopts", ?_assert(format(<<"[]">>,
[loose_unicode, {escape_forward_slash, true}]
) =:= <<"[]">>
)} )}
]. ].
ext_opts_test_() ->
[{"extopts", ?_assertEqual(
format(<<"[]">>, [loose_unicode, {escape_forward_slash, true}]),
<<"[]">>
)}].
-endif. -endif.

54
src/jsx_to_term.erl
View file

@ -102,35 +102,29 @@ format_key(Key, Opts) ->
basic_test_() -> basic_test_() ->
[ [
{"empty object", ?_assert(to_term(<<"{}">>, []) =:= [{}])}, {"empty object", ?_assertEqual(to_term(<<"{}">>, []), [{}])},
{"simple object", ?_assert(to_term(<<"{\"key\": true}">>, []) =:= [{<<"key">>, true}])}, {"simple object", ?_assertEqual(to_term(<<"{\"key\": true}">>, []), [{<<"key">>, true}])},
{"less simple object", {"less simple object", ?_assertEqual(
?_assert(to_term(<<"{\"a\": 1, \"b\": 2}">>, []) =:= [{<<"a">>, 1}, {<<"b">>, 2}]) to_term(<<"{\"a\": 1, \"b\": 2}">>, []),
}, [{<<"a">>, 1}, {<<"b">>, 2}]
{"nested object", )},
?_assert(to_term(<<"{\"key\": {\"key\": true}}">>, []) =:= [{<<"key">>, [{<<"key">>, true}]}]) {"nested object", ?_assertEqual(
}, to_term(<<"{\"key\": {\"key\": true}}">>, []),
[{<<"key">>, [{<<"key">>, true}]}]
)},
{"empty array", ?_assert(to_term(<<"[]">>, []) =:= [])}, {"empty array", ?_assert(to_term(<<"[]">>, []) =:= [])},
{"list of lists", {"list of lists", ?_assertEqual(to_term(<<"[[],[],[]]">>, []), [[], [], []])},
?_assert(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 strings", {"list of literals", ?_assertEqual(to_term(<<"[true,false,null]">>, []), [true,false,null])},
?_assert(to_term(<<"[\"hi\", \"there\"]">>, []) =:= [<<"hi">>, <<"there">>]) {"list of objects", ?_assertEqual(
}, to_term(<<"[{}, {\"a\":1, \"b\":2}, {\"key\":[true,false]}]">>, []),
{"list of numbers", [[{}], [{<<"a">>,1},{<<"b">>,2}], [{<<"key">>,[true,false]}]]
?_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]}]])
}
]. ].
comprehensive_test_() -> comprehensive_test_() ->
{"comprehensive test", ?_assert(to_term(comp_json(), []) =:= comp_term())}. {"comprehensive test", ?_assertEqual(to_term(comp_json(), []), comp_term())}.
comp_json() -> comp_json() ->
<<"[ <<"[
@ -157,7 +151,7 @@ comp_term() ->
]. ].
atom_labels_test_() -> 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() -> atom_term() ->
[ [
@ -173,10 +167,10 @@ atom_term() ->
naked_test_() -> naked_test_() ->
[ [
{"naked integer", ?_assert(to_term(<<"123">>, []) =:= 123)}, {"naked integer", ?_assertEqual(to_term(<<"123">>, []), 123)},
{"naked float", ?_assert(to_term(<<"-4.32e-17">>, []) =:= -4.32e-17)}, {"naked float", ?_assertEqual(to_term(<<"-4.32e-17">>, []), -4.32e-17)},
{"naked literal", ?_assert(to_term(<<"true">>, []) =:= true)}, {"naked literal", ?_assertEqual(to_term(<<"true">>, []), true)},
{"naked string", ?_assert(to_term(<<"\"string\"">>, []) =:= <<"string">>)} {"naked string", ?_assertEqual(to_term(<<"\"string\"">>, []), <<"string">>)}
]. ].
-endif. -endif.

6
src/jsx_verify.erl
View file

@ -169,11 +169,7 @@ term_true_test_() ->
{"empty array", ?_assert(is_term([], []))}, {"empty array", ?_assert(is_term([], []))},
{"whitespace", ?_assert(is_term([ true ], []))}, {"whitespace", ?_assert(is_term([ true ], []))},
{"nested terms", {"nested terms",
?_assert(is_term( ?_assert(is_term([[{x, [[{}], [{}], [{}]]}, {y, [{}]}], [{}], [[[]]]], []))
[[{x, [[{}], [{}], [{}]]}, {y, [{}]}], [{}], [[[]]]],
[]
)
)
}, },
{"numbers", {"numbers",
?_assert(is_term([-1.0, -1, -0, 0, 1.0e-1, 1, 1.0, 1.0e1], [])) ?_assert(is_term([-1.0, -1, -0, 0, 1.0e-1, 1, 1.0, 1.0e1], []))