more tests, up to 90% code coverage

src/jsx_verify.erl

@@ -88,68 +88,146 @@ handle_event(_, State) -> State.
 -ifdef(TEST).
 -include_lib("eunit/include/eunit.hrl").
 
-true_test_() ->
+json_true_test_() ->
     [
-        {"empty object", ?_assert(is_json(<<"{}">>, []) =:= true)},
+        {"empty object", ?_assert(is_json(<<"{}">>, []))},
-        {"empty array", ?_assert(is_json(<<"[]">>, []) =:= true)},
+        {"empty array", ?_assert(is_json(<<"[]">>, []))},
         {"whitespace", 
             ?_assert(is_json(<<" \n    \t   \r   [true]   \t    \n\r  ">>, 
                     []
-                ) =:= true
+                )
             )
         },
         {"nested terms", 
             ?_assert(is_json(
                     <<"[{ \"x\": [ {}, {}, {} ], \"y\": [{}] }, {}, [[[]]]]">>, 
                     []
-                ) =:= true
+                )
             )
         },
         {"numbers", 
             ?_assert(is_json(
                     <<"[ -1.0, -1, -0, 0, 1e-1, 1, 1.0, 1e1 ]">>, 
                     []
-                ) =:= true
+                )
             )
         },
         {"strings", 
             ?_assert(is_json(
                     <<"[ \"a\", \"string\", \"in\", \"multiple\", \"acts\" ]">>, 
                     []
-                ) =:= true
+                )
             )
         },
         {"literals", 
-            ?_assert(is_json(<<"[ true, false, null ]">>, []) =:= true)
+            ?_assert(is_json(<<"[ true, false, null ]">>, []))
         },
         {"nested objects", 
-            ?_assert(is_json(<<"{\"key\": { \"key\": true}}">>, []) =:= true)
+            ?_assert(is_json(<<"{\"key\": { \"key\": true}}">>, []))
         },        
-        {"repeated key ok", ?_assert(is_json(<<"{\"key\": true, \"key\": true}">>, []) =:= true)},
+        {"repeated key ok", ?_assert(is_json(
-        {"nested repeated key", ?_assert(is_json(<<"{\"key\": { \"key\": true }}">>,
+                    <<"{\"key\": true, \"key\": true}">>,
-            [{repeated_keys, false}]) =:= true)
+                    [repeated_keys]
+                )
+            )
+        },
+        {"nested repeated key", ?_assert(is_json(
+                    <<"{\"key\": { \"key\": true }}">>,
+                    [{repeated_keys, false}]
+                )
+            )
         }
     ].
 
-false_test_() ->
+json_false_test_() ->
     [
-        {"unbalanced list", ?_assert(is_json(<<"[]]">>, []) =:= false)},
+        {"unbalanced list", ?_assertNot(is_json(<<"[]]">>, []))},
         {"trailing comma", 
-            ?_assert(is_json(<<"[ true, false, null, ]">>, []) =:= false)
+            ?_assertNot(is_json(<<"[ true, false, null, ]">>, []))
         },
-        {"unquoted key", ?_assert(is_json(<<"{ key: false }">>, []) =:= false)},
+        {"unquoted key", ?_assertNot(is_json(<<"{ key: false }">>, []))},
-        {"repeated key", ?_assert(is_json(<<"{\"key\": true, \"key\": true}">>,
+        {"repeated key", ?_assertNot(is_json(
-            [{repeated_keys, false}]) =:= false)
+                <<"{\"key\": true, \"key\": true}">>,
+                [{repeated_keys, false}])
+            )
         },
-        {"nested repeated key", ?_assert(is_json(<<"{\"key\": { \"a\": true, \"a\": false }}">>,
+        {"nested repeated key", ?_assertNot(is_json(
-            [{repeated_keys, false}]) =:= false)
+                <<"{\"key\": { \"a\": true, \"a\": false }}">>,
+                [{repeated_keys, false}])
+            )
         }
     ].
 
-incomplete_test_() ->
+json_incomplete_test_() ->
     [
         {"incomplete test", ?_assertMatch({incomplete, _}, is_json(<<"[">>, []))}
     ].
+
+term_true_test_() ->
+    [
+        {"empty object", ?_assert(is_term([{}], []))},
+        {"empty array", ?_assert(is_term([], []))},
+        {"whitespace", ?_assert(is_term([    true      ], []))},
+        {"nested terms", 
+            ?_assert(is_term(
+                    [[{x, [[{}], [{}], [{}]]}, {y, [{}]}], [{}], [[[]]]],
+                    []
+                )
+            )
+        },
+        {"numbers", 
+            ?_assert(is_term([-1.0, -1, -0, 0, 1.0e-1, 1, 1.0, 1.0e1], []))
+        },
+        {"strings", 
+            ?_assert(is_term(
+                    [<<"a">>, <<"string">>, <<"in">>, <<"multiple">>, <<"acts">>], 
+                    []
+                )
+            )
+        },
+        {"literals", ?_assert(is_term([ true, false, null ], []))},
+        {"nested objects", ?_assert(is_term([{key, [{key, true}]}], []))},        
+        {"repeated key ok", ?_assert(is_term(
+                    [{key, true}, {key, true}],
+                    []
+                )
+            )
+        },
+        {"nested repeated key", ?_assert(is_term(
+                    [{key, [{key, true}]}],
+                    [{repeated_keys, false}]
+                )
+            )
+        }
+    ].
+
+term_false_test_() ->
+    [
+        {"repeated key", ?_assertNot(is_term(
+                    [{<<"key">>, true}, {<<"key">>, true}],
+                    [{repeated_keys, false}]
+                )
+            )
+        },
+        {"repeated key alternate representation", ?_assertNot(is_term(
+                    [{<<"key">>, true}, {key, true}],
+                    [{repeated_keys, false}]
+                )
+            )
+        },
+        {"repeated key alternate representation two", ?_assertNot(is_term(
+                    [{key, true}, {'key', true}],
+                    [{repeated_keys, false}]
+                )
+            )
+        },
+        {"nested repeated key", ?_assertNot(is_term(
+                    [{key, [{a, true}, {a, false}]}],
+                    [{repeated_keys, false}]
+                )
+            )
+        }
+    ].
         
     
 -endif.