エラー時に例外送出を行わないように変更中 (hipe時でもエラー原因を追えるようにするために)

rebar.config

@@ -3,6 +3,7 @@
             warnings_as_errors,
             warn_export_all,
             warn_untyped_record,
+            native,
             inline
            ]}. 
 

src/jsone.erl

@@ -30,8 +30,8 @@
 %% Exported API
 %%--------------------------------------------------------------------------------
 -export([
-         decode/1,
-         encode/1
+         decode/1, try_decode/1,
+         encode/1%, try_encode/1
         ]).
 
 -export_type([
@@ -52,7 +52,7 @@
 -type json_number()         :: number().
 -type json_string()         :: binary().
 -type json_array()          :: [json_value()].
--type json_object()         :: {object, json_object_members()}.
+-type json_object()         :: {json_object_members()}.
 -type json_object_members() :: [{json_string(), json_value()}].
 
 %%--------------------------------------------------------------------------------
@@ -61,8 +61,16 @@
 %% @doc JSONバイナリをデコードする.
 %%
 %% デコードに失敗した場合はエラーが送出される
--spec decode(binary()) -> {json_value(), RestJson::binary()}.
+-spec decode(binary()) -> json_value().
 decode(Json) ->
+    case try_decode(Json) of
+        {ok, Value, _}                -> Value;
+        {error, {Reason, StackTrace}} -> erlang:raise(error, Reason, StackTrace)
+    end.
+
+%% @doc JSONバイナリをデコードする.
+-spec try_decode(binary()) -> {ok, json_value(), Rest::binary()} | {error, {Reason::term(), [erlang:stack_item()]}}.
+try_decode(Json) ->
     jsone_decode:decode(Json).
 
 %% @doc JSON値をバイナリ形式にエンコードする.

src/jsone_decode.erl

@@ -35,6 +35,8 @@
 %%--------------------------------------------------------------------------------
 %% Macros & Types
 %%--------------------------------------------------------------------------------
+-define(ERROR(Function, Args), {error, {badarg, [{?MODULE, Function, Args, [{line, ?LINE}]}]}}).
+
 -type next() :: {array_next, [jsone:json_value()]}
               | {object_value, jsone:json_object_members()}
               | {object_next, jsone:json_string(), jsone:json_object_members()}.
@@ -47,22 +49,22 @@
                          | {object_value, jsone:json_string(), jsone:json_object_members()}
                          | {object_next, jsone:json_string(), jsone:json_value(), jsone:json_object_members()}.
 
+-type decode_result() :: {ok, jsone:json_value(), Rest::binary()} | {error, {Reason::term(), [erlang:stack_item()]}}.
+
 %%--------------------------------------------------------------------------------
 %% Exported Functions
 %%--------------------------------------------------------------------------------
 %% @doc JSONバイナリをデコードする.
-%%
-%% デコードに失敗した場合は`{invalid_json, 失敗位置より後のJSON::binary()}'形式のエラーが送出される.
--spec decode(binary()) -> {jsone:json_value(), RestJson::binary()}.
+-spec decode(binary()) -> decode_result().
 decode(<<Json/binary>>) ->
     whitespace(Json, value, [], <<"">>).
 
 %%--------------------------------------------------------------------------------
 %% Internal Functions
 %%--------------------------------------------------------------------------------
--spec next(binary(), jsone:json_value(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec next(binary(), jsone:json_value(), [next()], binary()) -> decode_result().
 next(<<Bin/binary>>, Value, [], _Buf) ->
-    {Value, Bin};
+    {ok, Value, Bin};
 next(<<Bin/binary>>, Value, [Next | Nexts], Buf) ->
     case Next of
         {array_next, Values}        -> whitespace(Bin, {array_next, [Value | Values]}, Nexts, Buf);
@@ -70,7 +72,7 @@ next(<<Bin/binary>>, Value, [Next | Nexts], Buf) ->
         {object_next, Key, Members} -> whitespace(Bin, {object_next, Key, Value, Members}, Nexts, Buf)
     end.
 
--spec whitespace(binary(), whitespace_next(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec whitespace(binary(), whitespace_next(), [next()], binary()) -> decode_result().
 whitespace(<<$  , Bin/binary>>, Next, Nexts, Buf) -> whitespace(Bin, Next, Nexts, Buf);
 whitespace(<<$\t, Bin/binary>>, Next, Nexts, Buf) -> whitespace(Bin, Next, Nexts, Buf);
 whitespace(<<$\r, Bin/binary>>, Next, Nexts, Buf) -> whitespace(Bin, Next, Nexts, Buf);
@@ -82,14 +84,14 @@ whitespace(<<Bin/binary>>,      Next, Nexts, Buf) ->
         object -> object(Bin, Nexts, Buf);
         string -> case Bin of
                       <<$", Bin2/binary>> -> string(Bin2, byte_size(Buf), Nexts, Buf);
-                      _                   -> error(badarg, [Bin, Next, Nexts, Buf])
+                      _                   -> ?ERROR(whitespace, [Bin, Next, Nexts, Buf])
                   end;
         {array_next, Values}               -> array_next(Bin, Values, Nexts, Buf);
         {object_value, Key, Members}       -> object_value(Bin, Key, Members, Nexts, Buf);
         {object_next, Key, Value, Members} -> object_next(Bin, [{Key, Value} | Members], Nexts, Buf)
     end.
 
--spec value(binary(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec value(binary(), [next()], binary()) -> decode_result().
 value(<<"false", Bin/binary>>, Nexts, Buf) -> next(Bin, false, Nexts, Buf);
 value(<<"true", Bin/binary>>, Nexts, Buf)  -> next(Bin, true, Nexts, Buf);
 value(<<"null", Bin/binary>>, Nexts, Buf)  -> next(Bin, null, Nexts, Buf);
@@ -98,29 +100,29 @@ value(<<${, Bin/binary>>, Nexts, Buf)      -> whitespace(Bin, object, Nexts, Buf
 value(<<$", Bin/binary>>, Nexts, Buf)      -> string(Bin, byte_size(Buf), Nexts, Buf);
 value(<<Bin/binary>>, Nexts, Buf)          -> number(Bin, Nexts, Buf).
 
--spec array(binary(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec array(binary(), [next()], binary()) -> decode_result().
 array(<<$], Bin/binary>>, Nexts, Buf) -> next(Bin, [], Nexts, Buf);
 array(<<Bin/binary>>, Nexts, Buf)     -> whitespace(Bin, value, [{array_next, []} | Nexts], Buf).
 
--spec array_next(binary(), [jsone:json_value()], [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec array_next(binary(), [jsone:json_value()], [next()], binary()) -> decode_result().
 array_next(<<$], Bin/binary>>, Values, Nexts, Buf) -> next(Bin, lists:reverse(Values), Nexts, Buf);
 array_next(<<$,, Bin/binary>>, Values, Nexts, Buf) -> whitespace(Bin, value, [{array_next, Values} | Nexts], Buf);
-array_next(Bin,                Values, Nexts, Buf) -> error(badarg, [Bin, Values, Nexts, Buf]).
+array_next(Bin,                Values, Nexts, Buf) -> ?ERROR(array_next, [Bin, Values, Nexts, Buf]).
 
--spec object(binary(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec object(binary(), [next()], binary()) -> decode_result().
 object(<<$}, Bin/binary>>, Nexts, Buf) -> next(Bin, {[]}, Nexts, Buf);
 object(<<Bin/binary>>, Nexts, Buf) -> whitespace(Bin, string, [{object_value, []} | Nexts], Buf).
 
--spec object_value(binary(), jsone:json_string(), jsone:json_object_members(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec object_value(binary(), jsone:json_string(), jsone:json_object_members(), [next()], binary()) -> decode_result().
 object_value(<<$:, Bin/binary>>, Key, Members, Nexts, Buf) -> whitespace(Bin, value, [{object_next, Key, Members} | Nexts], Buf);
-object_value(Bin,                Key, Members, Nexts, Buf) -> error(badarg, [Bin, Key, Members, Nexts, Buf]).
+object_value(Bin,                Key, Members, Nexts, Buf) -> ?ERROR(object_value, [Bin, Key, Members, Nexts, Buf]).
 
--spec object_next(binary(), jsone:json_object_members(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec object_next(binary(), jsone:json_object_members(), [next()], binary()) -> decode_result().
 object_next(<<$}, Bin/binary>>, Members, Nexts, Buf) -> next(Bin, {Members}, Nexts, Buf);
 object_next(<<$,, Bin/binary>>, Members, Nexts, Buf) -> whitespace(Bin, string, [{object_value, Members} | Nexts], Buf);
-object_next(Bin,                Members, Nexts, Buf) -> error(badarg, [Bin, Members, Nexts, Buf]).
+object_next(Bin,                Members, Nexts, Buf) -> ?ERROR(object_next, [Bin, Members, Nexts, Buf]).
 
--spec string(binary(), non_neg_integer(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec string(binary(), non_neg_integer(), [next()], binary()) -> decode_result().
 string(<<$", Bin/binary>>, Start, Nexts, Buf) -> next(Bin, binary:part(Buf, Start, byte_size(Buf) - Start), Nexts, Buf);
 string(<<$\\, B/binary>>,  Start, Nexts, Buf) ->
     case B of
@@ -133,12 +135,12 @@ string(<<$\\, B/binary>>,  Start, Nexts, Buf) ->
         <<$r, Bin/binary>> -> string(Bin, Start, Nexts, <<Buf/binary, $\r>>);
         <<$t, Bin/binary>> -> string(Bin, Start, Nexts, <<Buf/binary, $\t>>);
         <<$u, Bin/binary>> -> unicode_string(Bin, Start, Nexts, Buf);
-        _                  -> error(badarg, [<<$\\, B/binary>>, Start, Nexts, Buf])
+        _                  -> ?ERROR(string, [<<$\\, B/binary>>, Start, Nexts, Buf])
     end;
 string(<<C, Bin/binary>>, Start, Nexts, Buf) when 16#20 =< C ->
     string(Bin, Start, Nexts, <<Buf/binary, C>>).
 
--spec unicode_string(binary(), non_neg_integer(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec unicode_string(binary(), non_neg_integer(), [next()], binary()) -> decode_result().
 unicode_string(<<N:4/binary, Bin/binary>>, Start, Nexts, Buf) ->
     case binary_to_integer(N, 16) of
         High when 16#D800 =< High, High =< 16#DBFF ->
@@ -149,17 +151,17 @@ unicode_string(<<N:4/binary, Bin/binary>>, Start, Nexts, Buf) ->
                         Low when 16#DC00 =< Low, Low =< 16#DFFF ->
                             Unicode = 16#10000 + (High - 16#D800) * 16#400 + (Low - 16#DC00),
                             string(Bin2, Start, Nexts, unicode_to_utf8(Unicode, Buf));
-                        _ -> error(badarg, [<<N/binary, Bin/binary>>, Start, Nexts, Buf])
+                        _ -> ?ERROR(unicode_string, [<<N/binary, Bin/binary>>, Start, Nexts, Buf])
                     end;
-                _ -> error(badarg, [<<N/binary, Bin/binary>>, Start, Nexts, Buf])
+                _ -> ?ERROR(unicode_string, [<<N/binary, Bin/binary>>, Start, Nexts, Buf])
             end;
         Unicode when 16#DC00 =< Unicode, Unicode =< 16#DFFF ->  % サロゲートペアの後半部分
-            error(badarg, [<<N/binary, Bin/binary>>, Start, Nexts, Buf]);
+            ?ERROR(unicode_string, [<<N/binary, Bin/binary>>, Start, Nexts, Buf]);
         Unicode -> 
             string(Bin, Start, Nexts, unicode_to_utf8(Unicode, Buf))
     end;
 unicode_string(Bin, Acc, Nexts, Buf) ->
-    error(badarg, [Bin, Acc, Nexts, Buf]).
+    ?ERROR(unicode_string, [Bin, Acc, Nexts, Buf]).
 
 -spec unicode_to_utf8(0..1114111, binary()) -> binary().
 unicode_to_utf8(Code, Buf) when Code < 16#80 ->
@@ -180,39 +182,39 @@ unicode_to_utf8(Code, Buf) -> % NOTE: サロゲートペアの仕組み上、コ
     D = 2#10000000 bor (Code band 2#111111),
     <<Buf/binary, A, B, C, D>>.
 
--spec number(binary(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec number(binary(), [next()], binary()) -> decode_result().
 number(<<$-, Bin/binary>>, Nexts, Buf) -> number_integer_part(Bin, -1, Nexts, Buf);
 number(<<Bin/binary>>,     Nexts, Buf) -> number_integer_part(Bin,  1, Nexts, Buf).
 
--spec number_integer_part(binary(), 1|-1, [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec number_integer_part(binary(), 1|-1, [next()], binary()) -> decode_result().
 number_integer_part(<<$0, Bin/binary>>, Sign, Nexts, Buf) ->
     number_fraction_part(Bin, Sign, 0, Nexts, Buf);
 number_integer_part(<<C, Bin/binary>>, Sign, Nexts, Buf) when $1 =< C, C =< $9 ->
     number_integer_part_rest(Bin, C - $0, Sign, Nexts, Buf);
 number_integer_part(Bin, Sign, Nexts, Buf) ->
-    error(badarg, [Bin, Sign, Nexts, Buf]).
+    ?ERROR(number_integer_part, [Bin, Sign, Nexts, Buf]).
 
--spec number_integer_part_rest(binary(), non_neg_integer(), 1|-1, [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec number_integer_part_rest(binary(), non_neg_integer(), 1|-1, [next()], binary()) -> decode_result().
 number_integer_part_rest(<<C, Bin/binary>>, N, Sign, Nexts, Buf) when $0 =< C, C =< $9 ->
     number_integer_part_rest(Bin, N * 10 + C - $0, Sign, Nexts, Buf);
 number_integer_part_rest(<<Bin/binary>>, N, Sign, Nexts, Buf) ->
     number_fraction_part(Bin, Sign, N, Nexts, Buf).
 
--spec number_fraction_part(binary(), 1|-1, non_neg_integer(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec number_fraction_part(binary(), 1|-1, non_neg_integer(), [next()], binary()) -> decode_result().
 number_fraction_part(<<$., Bin/binary>>, Sign, Int, Nexts, Buf) ->
     number_fraction_part_rest(Bin, Sign, Int, 0, Nexts, Buf);
 number_fraction_part(<<Bin/binary>>, Sign, Int, Nexts, Buf) ->
     number_exponation_part(Bin, Sign * Int, 0, Nexts, Buf).
 
--spec number_fraction_part_rest(binary(), 1|-1, non_neg_integer(), non_neg_integer(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec number_fraction_part_rest(binary(), 1|-1, non_neg_integer(), non_neg_integer(), [next()], binary()) -> decode_result().
 number_fraction_part_rest(<<C, Bin/binary>>, Sign, N, DecimalOffset, Nexts, Buf) when $0 =< C, C =< $9 ->
     number_fraction_part_rest(Bin, Sign, N * 10 + C - $0, DecimalOffset + 1, Nexts, Buf);
 number_fraction_part_rest(<<Bin/binary>>, Sign, N, DecimalOffset, Nexts, Buf) when DecimalOffset > 0 ->
     number_exponation_part(Bin, Sign * N, DecimalOffset, Nexts, Buf);
 number_fraction_part_rest(Bin, Sign, N, DecimalOffset, Nexts, Buf) ->
-    error(badarg, [Bin, Sign, N, DecimalOffset, Nexts, Buf]).
+    ?ERROR(number_fraction_part_rest, [Bin, Sign, N, DecimalOffset, Nexts, Buf]).
 
--spec number_exponation_part(binary(), integer(), non_neg_integer(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec number_exponation_part(binary(), integer(), non_neg_integer(), [next()], binary()) -> decode_result().
 number_exponation_part(<<$e, $+, Bin/binary>>, N, DecimalOffset, Nexts, Buf) ->
     number_exponation_part(Bin, N, DecimalOffset, 1, 0, true, Nexts, Buf);
 number_exponation_part(<<$E, $+, Bin/binary>>, N, DecimalOffset, Nexts, Buf) ->
@@ -231,11 +233,11 @@ number_exponation_part(<<Bin/binary>>, N, DecimalOffset, Nexts, Buf) ->
         _ -> next(Bin, N / math:pow(10, DecimalOffset), Nexts, Buf)
     end.
 
--spec number_exponation_part(binary(), integer(), non_neg_integer(), 1|-1, non_neg_integer(), boolean(), [next()], binary()) -> {jsone:json_value(), Rest::binary()}.
+-spec number_exponation_part(binary(), integer(), non_neg_integer(), 1|-1, non_neg_integer(), boolean(), [next()], binary()) -> decode_result().
 number_exponation_part(<<C, Bin/binary>>, N, DecimalOffset, ExpSign, Exp, _, Nexts, Buf) when $0 =< C, C =< $9 ->
     number_exponation_part(Bin, N, DecimalOffset, ExpSign, Exp * 10 + C - $0, false, Nexts, Buf);
 number_exponation_part(<<Bin/binary>>, N, DecimalOffset, ExpSign, Exp, false, Nexts, Buf) ->
     Pos = ExpSign * Exp - DecimalOffset,
     next(Bin, N * math:pow(10, Pos), Nexts, Buf);
 number_exponation_part(Bin, N, DecimalOffset, ExpSign, Exp, IsFirst, Nexts, Buf) ->
-    error(badarg, [Bin, N, DecimalOffset, ExpSign, Exp, IsFirst, Nexts, Buf]).
+    ?ERROR(number_exponation_part, [Bin, N, DecimalOffset, ExpSign, Exp, IsFirst, Nexts, Buf]).

test/jsone_decode_tests.erl

@@ -8,114 +8,114 @@ decode_test_() ->
      %% シンボル系
      {"'false'がデコード可能",
       fun () ->
-              ?assertEqual({false, <<"">>}, jsone_decode:decode(<<"false">>))
+              ?assertEqual({ok, false, <<"">>}, jsone_decode:decode(<<"false">>))
       end},
      {"'true'がデコード可能",
       fun () ->
-              ?assertEqual({true, <<"">>}, jsone_decode:decode(<<"true">>))
+              ?assertEqual({ok, true, <<"">>}, jsone_decode:decode(<<"true">>))
       end},
      {"'null'がデコード可能",
       fun () ->
-              ?assertEqual({null, <<"">>}, jsone_decode:decode(<<"null">>))
+              ?assertEqual({ok, null, <<"">>}, jsone_decode:decode(<<"null">>))
       end},
      {"正の整数がデコード可能",
       fun () ->
-              ?assertEqual({1, <<"">>}, jsone_decode:decode(<<"1">>))
+              ?assertEqual({ok, 1, <<"">>}, jsone_decode:decode(<<"1">>))
       end},
 
      %% 数値系: 整数
      {"0がデコード可能",
       fun () ->
-              ?assertEqual({0, <<"">>}, jsone_decode:decode(<<"0">>))
+              ?assertEqual({ok, 0, <<"">>}, jsone_decode:decode(<<"0">>))
       end},
      {"負の整数がデコード可能",
       fun () ->
-              ?assertEqual({-1, <<"">>}, jsone_decode:decode(<<"-1">>))
+              ?assertEqual({ok, -1, <<"">>}, jsone_decode:decode(<<"-1">>))
       end},
      {"整数の値の大きさに制限はなし",
       fun () ->
-              ?assertEqual({111111111111111111111111111111111111111111111111111111111111111111111111111111, <<"">>},
+              ?assertEqual({ok, 111111111111111111111111111111111111111111111111111111111111111111111111111111, <<"">>},
                            jsone_decode:decode(<<"111111111111111111111111111111111111111111111111111111111111111111111111111111">>))
       end},
      {"先頭に余計な0がつく場合は、先頭文字とそれ以降が別々のトークンと判断される",
       fun () ->
-              ?assertEqual({0, <<"0">>}, jsone_decode:decode(<<"00">>)),
-              ?assertEqual({0, <<"1">>}, jsone_decode:decode(<<"01">>)),
-              ?assertEqual({0, <<"1">>}, jsone_decode:decode(<<"-01">>))
+              ?assertEqual({ok, 0, <<"0">>}, jsone_decode:decode(<<"00">>)),
+              ?assertEqual({ok, 0, <<"1">>}, jsone_decode:decode(<<"01">>)),
+              ?assertEqual({ok, 0, <<"1">>}, jsone_decode:decode(<<"-01">>))
       end},
      {"正の整数の前の'+'記号は許可されない",
       fun () ->
-              ?assertError(badarg, jsone_decode:decode(<<"+1">>))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"+1">>))
       end},
 
      %% 数値系: 小数
      {"小数がデコード可能",
       fun () ->
-              ?assertEqual({1.23, <<"">>}, jsone_decode:decode(<<"1.23">>))
+              ?assertEqual({ok, 1.23, <<"">>}, jsone_decode:decode(<<"1.23">>))
       end},
      {"指数形式の小数がデコード可能",
       fun () ->
-              ?assertEqual({12.345, <<"">>}, jsone_decode:decode(<<"12345e-3">>)),
-              ?assertEqual({12.345, <<"">>}, jsone_decode:decode(<<"12345E-3">>)), % 'e'は大文字でも可
-              ?assertEqual({12.345, <<"">>}, jsone_decode:decode(<<"12345.0e-3">>)),
-              ?assertEqual({12.345, <<"">>}, jsone_decode:decode(<<"0.12345E2">>)),
-              ?assertEqual({12.345, <<"">>}, jsone_decode:decode(<<"0.12345e+2">>)), % 指数部では'+'をつけても良い
-              ?assertEqual({12.345, <<"">>}, jsone_decode:decode(<<"0.12345E+2">>)), % 指数部では'+'をつけても良い
-              ?assertEqual({-12.345, <<"">>}, jsone_decode:decode(<<"-0.012345e3">>))
+              ?assertEqual({ok, 12.345, <<"">>}, jsone_decode:decode(<<"12345e-3">>)),
+              ?assertEqual({ok, 12.345, <<"">>}, jsone_decode:decode(<<"12345E-3">>)), % 'e'は大文字でも可
+              ?assertEqual({ok, 12.345, <<"">>}, jsone_decode:decode(<<"12345.0e-3">>)),
+              ?assertEqual({ok, 12.345, <<"">>}, jsone_decode:decode(<<"0.12345E2">>)),
+              ?assertEqual({ok, 12.345, <<"">>}, jsone_decode:decode(<<"0.12345e+2">>)), % 指数部では'+'をつけても良い
+              ?assertEqual({ok, 12.345, <<"">>}, jsone_decode:decode(<<"0.12345E+2">>)), % 指数部では'+'をつけても良い
+              ?assertEqual({ok, -12.345, <<"">>}, jsone_decode:decode(<<"-0.012345e3">>))
       end},
      {"不正な形式の小数",
       fun () ->
-              ?assertError(badarg, jsone_decode:decode(<<".123">>)),  % 整数部が省略されている
-              ?assertError(badarg, jsone_decode:decode(<<"0.">>)),    % '.'の後ろに小数部が続かない
-              ?assertError(badarg, jsone_decode:decode(<<"0.e+3">>)), % '.'の後ろに指数部が来る
-              ?assertError(badarg, jsone_decode:decode(<<"0.1e">>)),    % 指数部が欠けている
-              ?assertError(badarg, jsone_decode:decode(<<"0.1e-">>)),   % 指数部が欠けている
-              ?assertError(badarg, jsone_decode:decode(<<"0.1ee-1">>)), % 'e'が複数ある
-              ?assertError(badarg, jsone_decode:decode(<<"0.1e--1">>)), % 符号が複数ある
-              ?assertEqual({0.1, <<".2">>}, jsone_decode:decode(<<"0.1.2">>))  % '.'が複数ある => 別々のトークンと判断される
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<".123">>)),  % 整数部が省略されている
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"0.">>)),    % '.'の後ろに小数部が続かない
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"0.e+3">>)), % '.'の後ろに指数部が来る
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"0.1e">>)),    % 指数部が欠けている
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"0.1e-">>)),   % 指数部が欠けている
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"0.1ee-1">>)), % 'e'が複数ある
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"0.1e--1">>)), % 符号が複数ある
+              ?assertEqual({ok, 0.1, <<".2">>}, jsone_decode:decode(<<"0.1.2">>))  % '.'が複数ある => 別々のトークンと判断される
       end},
      
      %% 文字列系
      {"文字列がデコード可能",
       fun () ->
-              ?assertEqual({<<"abc">>,  <<"">>}, jsone_decode:decode(<<"\"abc\"">>))
+              ?assertEqual({ok, <<"abc">>,  <<"">>}, jsone_decode:decode(<<"\"abc\"">>))
       end},
      {"各種エスケープ文字がデコード可能",
       fun () ->
               Input    = list_to_binary([$", [[$\\, C] || C <- [$", $/, $\\, $b, $f, $n, $r, $t]], $"]),
               Expected = <<"\"\/\\\b\f\n\r\t">>,
-              ?assertEqual({Expected, <<"">>}, jsone_decode:decode(Input))
+              ?assertEqual({ok, Expected, <<"">>}, jsone_decode:decode(Input))
       end},
      {"エスケープされたUTF-16文字列がデコード可能",
       fun () ->
               %% 日本語
               Input1    = <<"\"\\u3042\\u3044\\u3046\\u3048\\u304A\"">>,
               Expected1 = <<"あいうえお">>,  % このファイルの文字エンコーディングがUTF-8であることが前提
-              ?assertEqual({Expected1, <<"">>}, jsone_decode:decode(Input1)),
+              ?assertEqual({ok, Expected1, <<"">>}, jsone_decode:decode(Input1)),
 
               %% ascii
               Input2    = <<"\"\\u0061\\u0062\\u0063\"">>,
               Expected2 = <<"abc">>,
-              ?assertEqual({Expected2, <<"">>}, jsone_decode:decode(Input2)),
+              ?assertEqual({ok, Expected2, <<"">>}, jsone_decode:decode(Input2)),
 
               %% 日本語以外のマルチバイト文字
               Input3    = <<"\"\\u06DD\\u06DE\\u10AE\\u10AF\"">>,
               Expected3 = <<"۝۞ႮႯ">>,
-              ?assertEqual({Expected3, <<"">>}, jsone_decode:decode(Input3))
+              ?assertEqual({ok, Expected3, <<"">>}, jsone_decode:decode(Input3))
       end},
      {"サロゲートペアを含む文字列がデコード可能",
       fun () ->
               Input    = <<"\"\\ud848\\udc49\\ud848\\udc9a\\ud848\\udcfc\"">>,
               Expected = <<"𢁉𢂚𢃼">>,
-              ?assertEqual({Expected, <<"">>}, jsone_decode:decode(Input))
+              ?assertEqual({ok, Expected, <<"">>}, jsone_decode:decode(Input))
       end},
      {"不正なエスケープ文字",
       fun () ->
-              ?assertError(badarg, jsone_decode:decode(<<"\"\\z\"">>)),    % '\z'は未定義のエスケープ文字
-              ?assertError(badarg, jsone_decode:decode(<<"\"\\uab\"">>)),  % '\u'の後ろに続く数値が足りない
-              ?assertError(badarg, jsone_decode:decode(<<"\"\\ud848\"">>)), % 上位サロゲートが単独で出現
-              ?assertError(badarg, jsone_decode:decode(<<"\"\\udc49\"">>)), % 下位サロゲーが単独で出現
-              ?assertError(badarg, jsone_decode:decode(<<"\"\\ud848\\u0061\"">>)) % 上位サロゲートの後ろに下位サロゲートが続かない
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"\"\\z\"">>)),    % '\z'は未定義のエスケープ文字
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"\"\\uab\"">>)),  % '\u'の後ろに続く数値が足りない
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"\"\\ud848\"">>)), % 上位サロゲートが単独で出現
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"\"\\udc49\"">>)), % 下位サロゲーが単独で出現
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(<<"\"\\ud848\\u0061\"">>)) % 上位サロゲートの後ろに下位サロゲートが続かない
       end},
 
      %% 配列系
@@ -123,27 +123,27 @@ decode_test_() ->
       fun () ->
               Input    = <<"[1, 2, \"abc\", null]">>,
               Expected = [1, 2, <<"abc">>, null],
-              ?assertEqual({Expected, <<"">>}, jsone_decode:decode(Input))
+              ?assertEqual({ok, Expected, <<"">>}, jsone_decode:decode(Input))
       end},
      {"空配列がデコード可能",
       fun () ->
-              ?assertEqual({[], <<"">>}, jsone_decode:decode(<<"[]">>)),
-              ?assertEqual({[], <<"">>}, jsone_decode:decode(<<"[ \t\r\n]">>))
+              ?assertEqual({ok, [], <<"">>}, jsone_decode:decode(<<"[]">>)),
+              ?assertEqual({ok, [], <<"">>}, jsone_decode:decode(<<"[ \t\r\n]">>))
       end},
      {"配列の末尾のカンマは許容されない",
       fun () ->
               Input = <<"[1, 2, \"abc\", null, ]">>,
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
      {"区切り文字のカンマが抜けているとエラーとなる",
       fun () ->
               Input = <<"[1 2, \"abc\", null]">>, % 1と2の間にカンマがない
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
      {"配列が閉じていないとエラー",
       fun () ->
               Input = <<"[1, 2, \"abc\", null">>,
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
 
      %% オブジェクト系
@@ -151,43 +151,43 @@ decode_test_() ->
       fun () ->
               Input    = <<"{\"1\":2, \"key\":\"value\"}">>,
               Expected = {[{<<"key">>, <<"value">>}, {<<"1">>, 2}]},
-              ?assertEqual({Expected, <<"">>}, jsone_decode:decode(Input))
+              ?assertEqual({ok, Expected, <<"">>}, jsone_decode:decode(Input))
       end},
      {"空オブジェクトがデコード可能",
       fun () ->
-              ?assertEqual({{[]}, <<"">>}, jsone_decode:decode(<<"{}">>)),
-              ?assertEqual({{[]}, <<"">>}, jsone_decode:decode(<<"{ \t\r\n}">>))
+              ?assertEqual({ok, {[]}, <<"">>}, jsone_decode:decode(<<"{}">>)),
+              ?assertEqual({ok, {[]}, <<"">>}, jsone_decode:decode(<<"{ \t\r\n}">>))
       end},
      {"オブジェクトの末尾のカンマは許容されない",
       fun () ->
               Input = <<"{\"1\":2, \"key\":\"value\", }">>,
               io:format("~p\n", [catch jsone_decode:decode(Input)]),
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
      {"区切り文字のカンマが抜けているとエラーとなる",
       fun () ->
               Input = <<"{\"1\":2 \"key\":\"value\"}">>,
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
      {"メンバのキーがない場合はエラー",
       fun () ->
               Input = <<"{:2, \"key\":\"value\"}">>,
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
      {"メンバのキーが文字列以外の場合はエラー",
       fun () ->
               Input = <<"{1:2, \"key\":\"value\"}">>,
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
      {"メンバの値がない場合はエラー",
       fun () ->
               Input = <<"{\"1\", \"key\":\"value\"}">>,
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
      {"オブジェクトが閉じていないとエラー",
       fun () ->
               Input = <<"{\"1\":2 \"key\":\"value\"">>,
-              ?assertError(badarg, jsone_decode:decode(Input))
+              ?assertMatch({error, {badarg, _}}, jsone_decode:decode(Input))
       end},
 
      %% その他
@@ -195,6 +195,6 @@ decode_test_() ->
       fun () ->
               Input    = <<"  [true, {\"1\" : 2, \"array\":[[[[1]]], {\"ab\":\"cd\"}, false]}, null]   ">>,
               Expected = [true, {[{<<"array">>, [[[[1]]], {[{<<"ab">>, <<"cd">>}]}, false]}, {<<"1">>, 2}]}, null],
-              ?assertEqual({Expected, <<"   ">>}, jsone_decode:decode(Input))
+              ?assertEqual({ok, Expected, <<"   ">>}, jsone_decode:decode(Input))
       end}
     ].