remove all ?_assert and replace with ?_assertFoo's
This commit is contained in:
alisdair sullivan
parent
aef1f71690
commit
d2950ab8c7
4 changed files with 176 additions and 215 deletions
|
|
@ -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]
|
||||
)
|
||||
}
|
||||
].
|
||||
|
||||
|
|
|
|||
|
|
@ -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}">>
|
||||
)
|
||||
}
|
||||
].
|
||||
|
||||
ext_opts_test_() ->
|
||||
[{"extopts", ?_assert(format(<<"[]">>,
|
||||
[loose_unicode, {escape_forward_slash, true}]
|
||||
) =:= <<"[]">>
|
||||
{"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", ?_assertEqual(
|
||||
format(<<"[]">>, [loose_unicode, {escape_forward_slash, true}]),
|
||||
<<"[]">>
|
||||
)}].
|
||||
|
||||
-endif.
|
||||
|
|
@ -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.
|
||||
|
|
@ -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], []))
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue