エンコード処理をCPSで書き直し

README.md

@@ -1,4 +1,4 @@
-jsone (0.2.0)
+jsone (0.2.1)
 =============
 
 Erlangで実装されたJSONのエンコード/デコードライブラリ。

doc/jsone.md

@@ -58,7 +58,7 @@ json_number() = number()
 
 
 <pre><code>
-json_object() = {object, <a href="#type-json_object_members">json_object_members()</a>}
+json_object() = {<a href="#type-json_object_members">json_object_members()</a>}
 </code></pre>
 
 
@@ -103,7 +103,7 @@ json_value() = <a href="#type-json_number">json_number()</a> | <a href="#type-js
 ## Function Index ##
 
 
-<table width="100%" border="1" cellspacing="0" cellpadding="2" summary="function index"><tr><td valign="top"><a href="#decode-1">decode/1</a></td><td>JSONバイナリをデコードする.</td></tr><tr><td valign="top"><a href="#encode-1">encode/1</a></td><td>JSON値をバイナリ形式にエンコードする.</td></tr></table>
+<table width="100%" border="1" cellspacing="0" cellpadding="2" summary="function index"><tr><td valign="top"><a href="#decode-1">decode/1</a></td><td>JSONバイナリをデコードする.</td></tr><tr><td valign="top"><a href="#encode-1">encode/1</a></td><td>JSON値をバイナリ形式にエンコードする.</td></tr><tr><td valign="top"><a href="#try_decode-1">try_decode/1</a></td><td>JSONバイナリをデコードする.</td></tr><tr><td valign="top"><a href="#try_encode-1">try_encode/1</a></td><td>JSON値をバイナリ形式にエンコードする.</td></tr></table>
 
 
 <a name="functions"></a>
@@ -116,7 +116,7 @@ json_value() = <a href="#type-json_number">json_number()</a> | <a href="#type-js
 
 
 <pre><code>
-decode(Json::binary()) -&gt; {<a href="#type-json_value">json_value()</a>, RestJson::binary()}
+decode(Json::binary()) -&gt; <a href="#type-json_value">json_value()</a>
 </code></pre>
 
 <br></br>
@@ -144,3 +144,29 @@ JSON値をバイナリ形式にエンコードする.
 
 
 エンコードに失敗した場合はエラーが送出される
+<a name="try_decode-1"></a>
+
+### try_decode/1 ###
+
+
+<pre><code>
+try_decode(Json::binary()) -&gt; {ok, <a href="#type-json_value">json_value()</a>, Rest::binary()} | {error, {Reason::term(), [<a href="erlang.md#type-stack_item">erlang:stack_item()</a>]}}
+</code></pre>
+
+<br></br>
+
+
+JSONバイナリをデコードする.
+<a name="try_encode-1"></a>
+
+### try_encode/1 ###
+
+
+<pre><code>
+try_encode(JsonValue::<a href="#type-json_value">json_value()</a>) -&gt; {ok, binary()} | {error, {Reason::term(), [<a href="erlang.md#type-stack_item">erlang:stack_item()</a>]}}
+</code></pre>
+
+<br></br>
+
+
+JSON値をバイナリ形式にエンコードする

rebar.config

@@ -28,5 +28,5 @@
  
 {deps,
   [
-%   {edown, ".*", {git, "git://github.com/sile/edown.git", {branch, "master"}}}
+%%   {edown, ".*", {git, "git://github.com/sile/edown.git", {branch, "master"}}}
   ]}.

src/jsone.app.src

@@ -2,7 +2,7 @@
 {application, jsone,
  [
   {description, "Erlang JSON Library"},
-  {vsn, "0.2.0"},
+  {vsn, "0.2.1"},
   {registered, []},
   {applications, [
                   kernel,

src/jsone.erl

@@ -31,7 +31,7 @@
 %%--------------------------------------------------------------------------------
 -export([
          decode/1, try_decode/1,
-         encode/1%, try_encode/1
+         encode/1, try_encode/1
         ]).
 
 -export_type([
@@ -63,9 +63,12 @@
 %% デコードに失敗した場合はエラーが送出される
 -spec decode(binary()) -> json_value().
 decode(Json) ->
-    case try_decode(Json) of
-        {ok, Value, _}                -> Value;
-        {error, {Reason, StackTrace}} -> erlang:raise(error, Reason, StackTrace)
+    try
+        {ok, Value, _} = try_decode(Json),
+        Value
+    catch
+        error:{badmatch, {error, {Reason, [StackItem]}}} ->
+            erlang:raise(error, Reason, [StackItem | erlang:get_stacktrace()])
     end.
 
 %% @doc JSONバイナリをデコードする.
@@ -78,4 +81,15 @@ try_decode(Json) ->
 %% エンコードに失敗した場合はエラーが送出される
 -spec encode(json_value()) -> binary().
 encode(JsonValue) ->
+    try
+        {ok, Binary} = try_encode(JsonValue),
+        Binary
+    catch
+        error:{badmatch, {error, {Reason, [StackItem]}}} ->
+            erlang:raise(error, Reason, [StackItem | erlang:get_stacktrace()])
+    end.
+
+%% @doc JSON値をバイナリ形式にエンコードする
+-spec try_encode(json_value()) -> {ok, binary()} | {error, {Reason::term(), [erlang:stack_item()]}}.
+try_encode(JsonValue) ->
     jsone_encode:encode(JsonValue).

src/jsone_encode.erl

@@ -35,6 +35,7 @@
 %%--------------------------------------------------------------------------------
 %% Macros
 %%--------------------------------------------------------------------------------
+-define(ERROR(Function, Args), {error, {badarg, [{?MODULE, Function, Args, [{line, ?LINE}]}]}}).
 -define(IS_REDUNDANT_UTF8(B1, B2, FirstBitN), (B1 =:= 0 andalso B2 < (1 bsl (FirstBitN + 1)))).
 -define(HEX(N, I), (binary:at(<<"0123456789abcdef">>, (N bsr (I * 4)) band 2#1111))).
 -define(UNICODE_TO_HEX(Code), ?HEX(Code, 3), ?HEX(Code, 2), ?HEX(Code, 1), ?HEX(Code, 0)).
@@ -43,84 +44,92 @@
 %% Exported Functions
 %%--------------------------------------------------------------------------------
 %% @doc JSON値をバイナリ形式にエンコードする.
--spec encode(jsone:json_value()) -> binary().
+% -spec encode(jsone:json_value()) -> binary().
 encode(Value) ->
-    value(Value, <<"">>).
+    value(Value, [], <<"">>).
 
 %%--------------------------------------------------------------------------------
 %% Internal Functions
 %%--------------------------------------------------------------------------------
--spec value(jsone:json_value(), binary()) -> binary().
-value(null, Buf)                         -> <<Buf/binary, "null">>;
-value(false, Buf)                        -> <<Buf/binary, "false">>;
-value(true, Buf)                         -> <<Buf/binary, "true">>;
-value(Value, Buf) when is_integer(Value) -> <<Buf/binary, (integer_to_binary(Value))/binary>>;
-value(Value, Buf) when is_float(Value)   -> <<Buf/binary, (float_to_binary(Value))/binary>>;
-value(Value, Buf) when is_binary(Value)  -> string(Value, Buf);
-value(Value, Buf) when is_list(Value)    -> array(Value, Buf);
-value({_} = Value, Buf)                  -> object(Value, Buf);
-value(Value, Buf)                        -> error(badarg, [Value, Buf]).
+next([], Buf)             -> {ok, Buf};
+next([Next | Nexts], Buf) ->
+    case Next of
+        {array_values, Values} ->
+            case Values of
+                [] -> array_values(Values, Nexts, Buf);
+                _  -> array_values(Values, Nexts, <<Buf/binary, $,>>)
+            end;
+        {object_value, Value, Members} ->
+            object_value(Value, Members, Nexts, Buf);
+        {object_members, Members} ->
+            case Members of
+                [] -> object_members(Members, Nexts, Buf);
+                _  -> object_members(Members, Nexts, <<Buf/binary, $,>>)
+            end
+    end.
+
+% -spec value(jsone:json_value(), binary()) -> binary().
+value(null, Nexts, Buf)                         -> next(Nexts, <<Buf/binary, "null">>);
+value(false, Nexts, Buf)                        -> next(Nexts, <<Buf/binary, "false">>);
+value(true, Nexts, Buf)                         -> next(Nexts, <<Buf/binary, "true">>);
+value(Value, Nexts, Buf) when is_integer(Value) -> next(Nexts, <<Buf/binary, (integer_to_binary(Value))/binary>>);
+value(Value, Nexts, Buf) when is_float(Value)   -> next(Nexts, <<Buf/binary, (float_to_binary(Value))/binary>>);
+value(Value, Nexts, Buf) when is_binary(Value)  -> string(Value, Nexts, Buf);
+value(Value, Nexts, Buf) when is_list(Value)    -> array(Value, Nexts, Buf);
+value({_} = Value, Nexts, Buf)                  -> object(Value, Nexts, Buf);
+value(Value, Nexts, Buf)                        -> ?ERROR(value, [Value, Nexts, Buf]).
 
--spec string(jsone:json_string(), binary()) -> binary().
-string(<<Str/binary>>, Buf) ->
-    escape_string(Str, <<Buf/binary, $">>).
+% -spec string(jsone:json_string(), binary()) -> binary().
+string(<<Str/binary>>, Nexts, Buf) ->
+    escape_string(Str, Nexts, <<Buf/binary, $">>).
 
--spec escape_string(binary(), binary()) -> binary().
-escape_string(<<"">>,                   Buf) -> <<Buf/binary, $">>;
-escape_string(<<$", Str/binary>>,       Buf) -> escape_string(Str, <<Buf/binary, $\\, $">>);
-escape_string(<<$\/, Str/binary>>,      Buf) -> escape_string(Str, <<Buf/binary, $\\, $\/>>);
-escape_string(<<$\\, Str/binary>>,      Buf) -> escape_string(Str, <<Buf/binary, $\\, $\\>>);
-escape_string(<<$\b, Str/binary>>,      Buf) -> escape_string(Str, <<Buf/binary, $\\, $b>>);
-escape_string(<<$\f, Str/binary>>,      Buf) -> escape_string(Str, <<Buf/binary, $\\, $f>>);
-escape_string(<<$\n, Str/binary>>,      Buf) -> escape_string(Str, <<Buf/binary, $\\, $n>>);
-escape_string(<<$\r, Str/binary>>,      Buf) -> escape_string(Str, <<Buf/binary, $\\, $r>>);
-escape_string(<<$\t, Str/binary>>,      Buf) -> escape_string(Str, <<Buf/binary, $\\, $t>>);
-escape_string(<<0:1, C:7, Str/binary>>, Buf) -> escape_string(Str, <<Buf/binary, C>>);
-escape_string(<<2#110:3, B1:5, 2#10:2, B2:6, Str/binary>>, Buf) when not ?IS_REDUNDANT_UTF8(B1, B2, 5) ->
+% -spec escape_string(binary(), binary()) -> binary().
+escape_string(<<"">>,                   Nexts, Buf) -> next(Nexts, <<Buf/binary, $">>);
+escape_string(<<$", Str/binary>>,       Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, $\\, $">>);
+escape_string(<<$\/, Str/binary>>,      Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, $\\, $\/>>);
+escape_string(<<$\\, Str/binary>>,      Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, $\\, $\\>>);
+escape_string(<<$\b, Str/binary>>,      Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, $\\, $b>>);
+escape_string(<<$\f, Str/binary>>,      Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, $\\, $f>>);
+escape_string(<<$\n, Str/binary>>,      Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, $\\, $n>>);
+escape_string(<<$\r, Str/binary>>,      Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, $\\, $r>>);
+escape_string(<<$\t, Str/binary>>,      Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, $\\, $t>>);
+escape_string(<<0:1, C:7, Str/binary>>, Nexts, Buf) -> escape_string(Str, Nexts, <<Buf/binary, C>>);
+escape_string(<<2#110:3, B1:5, 2#10:2, B2:6, Str/binary>>, Nexts, Buf) when not ?IS_REDUNDANT_UTF8(B1, B2, 5) ->
     Unicode = (B1 bsl 6) + B2,
-    escape_unicode_char(Str, Unicode, Buf);
-escape_string(<<2#1110:4, B1:4, 2#10:2, B2:6, 2#10:2, B3:6, Str/binary>>, Buf) when not ?IS_REDUNDANT_UTF8(B1, B2, 4) ->
+    escape_unicode_char(Str, Unicode, Nexts, Buf);
+escape_string(<<2#1110:4, B1:4, 2#10:2, B2:6, 2#10:2, B3:6, Str/binary>>, Nexts, Buf) when not ?IS_REDUNDANT_UTF8(B1, B2, 4) ->
     Unicode = (B1 bsl 12) + (B2 bsl 6) + B3,
-    escape_unicode_char(Str, Unicode, Buf);
-escape_string(<<2#11110:5, B1:3, 2#10:2, B2:6, 2#10:2, B3:6, 2#10:2, B4:6, Str/binary>>, Buf) when not ?IS_REDUNDANT_UTF8(B1, B2, 3) ->
+    escape_unicode_char(Str, Unicode, Nexts, Buf);
+escape_string(<<2#11110:5, B1:3, 2#10:2, B2:6, 2#10:2, B3:6, 2#10:2, B4:6, Str/binary>>, Nexts, Buf) when not ?IS_REDUNDANT_UTF8(B1, B2, 3) ->
     Unicode = (B1 bsl 18) + (B2 bsl 12) + (B3 bsl 6) + B4,
-    escape_unicode_char(Str, Unicode, Buf);
-escape_string(Str, Buf) ->
-    error(badarg, [Str, Buf]).
+    escape_unicode_char(Str, Unicode, Nexts, Buf);
+escape_string(Str, Nexts, Buf) ->
+    ?ERROR(escape_string, [Str, Nexts, Buf]).
 
--spec escape_unicode_char(binary(), char(), binary()) -> binary().
-escape_unicode_char(<<Str/binary>>, Unicode, Buf) when Unicode =< 16#FFFF ->
-    escape_string(Str, <<Buf/binary, $\\, $u, ?UNICODE_TO_HEX(Unicode)>>);
-escape_unicode_char(<<Str/binary>>, Unicode, Buf) ->
+% -spec escape_unicode_char(binary(), char(), binary()) -> binary().
+escape_unicode_char(<<Str/binary>>, Unicode, Nexts, Buf) when Unicode =< 16#FFFF ->
+    escape_string(Str, Nexts, <<Buf/binary, $\\, $u, ?UNICODE_TO_HEX(Unicode)>>);
+escape_unicode_char(<<Str/binary>>, Unicode, Nexts, Buf) ->
     %% サロゲートペア
     <<High:10, Low:10>> = <<(Unicode - 16#10000):20>>, % 非効率
-    escape_string(Str, <<Buf/binary, $\\, $u, ?UNICODE_TO_HEX(High + 16#D800), $\\, $u, ?UNICODE_TO_HEX(Low + 16#DC00)>>).
+    escape_string(Str, Nexts, <<Buf/binary, $\\, $u, ?UNICODE_TO_HEX(High + 16#D800), $\\, $u, ?UNICODE_TO_HEX(Low + 16#DC00)>>).
 
--spec array(jsone:json_array(), binary()) -> binary().
-array(List, Buf) ->
-    array_values(List, <<Buf/binary, $[>>).
+% -spec array(jsone:json_array(), binary()) -> binary().
+array(List, Nexts, Buf) ->
+    array_values(List, Nexts, <<Buf/binary, $[>>).
 
--spec array_values(jsone:json_array(), binary()) -> binary().
-array_values([],       Buf) -> <<Buf/binary, $]>>;
-array_values([X | Xs], Buf) ->
-    Buf2 = value(X, Buf),
-    case Xs of
-        [] -> <<Buf2/binary, $]>>;
-        _  -> array_values(Xs, <<Buf2/binary, $,>>)
-    end.
+% -spec array_values(jsone:json_array(), binary()) -> binary().
+array_values([],       Nexts, Buf) -> next(Nexts, <<Buf/binary, $]>>);
+array_values([X | Xs], Nexts, Buf) -> value(X, [{array_values, Xs} | Nexts], Buf).
+
+% -spec object(jsone:json_object(), binary()) -> binary().
+object({Members}, Nexts, Buf) ->
+    object_members(Members, Nexts, <<Buf/binary, ${>>).
 
--spec object(jsone:json_object(), binary()) -> binary().
-object({Members}, Buf) ->
-    object_members(Members, <<Buf/binary, ${>>).
+% -spec object_members(jsone:json_object_members(), binary()) -> binary().
+object_members([],                             Nexts, Buf) -> next(Nexts, <<Buf/binary, $}>>);
+object_members([{<<Key/binary>>, Value} | Xs], Nexts, Buf) -> string(Key, [{object_value, Value, Xs} | Nexts], Buf);
+object_members(Arg, Nexts, Buf)                            -> ?ERROR(object_members, [Arg, Nexts, Buf]).
 
--spec object_members(jsone:json_object_members(), binary()) -> binary().
-object_members([],                             Buf) -> <<Buf/binary, $}>>;
-object_members([{<<Key/binary>>, Value} | Xs], Buf) ->
-    Buf2 = string(Key, Buf),
-    Buf3 = value(Value, <<Buf2/binary, $:>>),
-    case Xs of
-        [] -> <<Buf3/binary, $}>>;
-        _  -> object_members(Xs, <<Buf3/binary, $,>>)
-    end;
-object_members(Arg, Buf) ->
-    error(badarg, [Arg, Buf]).
+object_value(Value, Members, Nexts, Buf) ->
+    value(Value, [{object_members, Members} | Nexts], <<Buf/binary, $:>>).

test/jsone_encode_tests.erl

@@ -8,72 +8,72 @@ encode_test_() ->
      %% シンボル系
      {"false がエンコード可能",
       fun () ->
-              ?assertEqual(<<"false">>, jsone_encode:encode(false))
+              ?assertEqual({ok, <<"false">>}, jsone_encode:encode(false))
       end},
      {"true がエンコード可能",
       fun () ->
-              ?assertEqual(<<"true">>, jsone_encode:encode(true))
+              ?assertEqual({ok, <<"true">>}, jsone_encode:encode(true))
       end},
      {"null がエンコード可能",
       fun () ->
-              ?assertEqual(<<"null">>, jsone_encode:encode(null))
+              ?assertEqual({ok, <<"null">>}, jsone_encode:encode(null))
       end},
 
      %% 数値系: 整数
      {"0がエンコード可能",
       fun () ->
-              ?assertEqual(<<"0">>, jsone_encode:encode(0))
+              ?assertEqual({ok, <<"0">>}, jsone_encode:encode(0))
       end},
      {"正の整数がエンコード可能",
       fun () ->
-              ?assertEqual(<<"1">>, jsone_encode:encode(1))
+              ?assertEqual({ok, <<"1">>}, jsone_encode:encode(1))
       end},
      {"負の整数がエンコード可能",
       fun () ->
-              ?assertEqual(<<"-1">>, jsone_encode:encode(-1))
+              ?assertEqual({ok, <<"-1">>}, jsone_encode:encode(-1))
       end},
      {"巨大な整数がエンコード可能",
       fun () ->
-              ?assertEqual(<<"11111111111111111111111111111111111111111111111111111111111111111111111">>,
+              ?assertEqual({ok, <<"11111111111111111111111111111111111111111111111111111111111111111111111">>},
                            jsone_encode:encode(11111111111111111111111111111111111111111111111111111111111111111111111))
       end},
 
      %% 数値系: 小数
      {"小数がエンコード可能",
       fun () ->
-              Input   = 1.234,
-              Encoded = jsone_encode:encode(Input),
-              ?assertEqual(Input, binary_to_float(Encoded))
+              Input = 1.234,
+              ?assertMatch({ok, _}, jsone_encode:encode(Input)),
+              ?assertEqual(Input, binary_to_float(element(2, jsone_encode:encode(Input))))
       end},
 
      %% 文字列系
      {"文字列がエンコード可能",
       fun () ->
-              ?assertEqual(<<"\"abc\"">>, jsone_encode:encode(<<"abc">>))
+              ?assertEqual({ok, <<"\"abc\"">>}, jsone_encode:encode(<<"abc">>))
       end},
      {"各種エスケープ文字を含む文字列をエンコード可能",
       fun () ->
               Input    = <<"\"\/\\\b\f\n\r\t">>,
               Expected = list_to_binary([$", [[$\\, C] || C <- [$", $/, $\\, $b, $f, $n, $r, $t]], $"]),
-              ?assertEqual(Expected, jsone_encode:encode(Input))
+              ?assertEqual({ok, Expected}, jsone_encode:encode(Input))
       end},
      {"UTF-8形式のマルチバイト文字列がエンコード可能",
       fun () ->
               %% 日本語
               Input1    = <<"あいうえお">>,  % このファイルの文字エンコーディングがUTF-8であることが前提
               Expected1 = <<"\"\\u3042\\u3044\\u3046\\u3048\\u304a\"">>,
-              ?assertEqual(Expected1, jsone_encode:encode(Input1)),
+              ?assertEqual({ok, Expected1}, jsone_encode:encode(Input1)),
 
               %% 日本語以外のマルチバイト文字
               Input2    = <<"۝۞ႮႯ">>,
               Expected2 = <<"\"\\u06dd\\u06de\\u10ae\\u10af\"">>,
-              ?assertEqual(Expected2, jsone_encode:encode(Input2))
+              ?assertEqual({ok, Expected2}, jsone_encode:encode(Input2))
       end},
      {"サロゲートペアを含む文字列がエンコード可能",
       fun () ->
               Input    = <<"𢁉𢂚𢃼">>,
               Expected = <<"\"\\ud848\\udc49\\ud848\\udc9a\\ud848\\udcfc\"">>,
-              ?assertEqual(Expected, jsone_encode:encode(Input))
+              ?assertEqual({ok, Expected}, jsone_encode:encode(Input))
       end},
 
      %% 配列系
@@ -81,13 +81,13 @@ encode_test_() ->
       fun () ->
               Input    = [1, 2, 3],
               Expected = <<"[1,2,3]">>,
-              ?assertEqual(Expected, jsone_encode:encode(Input))
+              ?assertEqual({ok, Expected}, jsone_encode:encode(Input))
       end},
      {"空配列がエンコード可能",
       fun () ->
               Input    = [],
               Expected = <<"[]">>,
-              ?assertEqual(Expected, jsone_encode:encode(Input))
+              ?assertEqual({ok, Expected}, jsone_encode:encode(Input))
       end},
 
      %% オブジェクト系
@@ -95,19 +95,19 @@ encode_test_() ->
       fun () ->
               Input    = {[{<<"key">>, <<"value">>}, {<<"1">>, 2}]},
               Expected = <<"{\"key\":\"value\",\"1\":2}">>,
-              ?assertEqual(Expected, jsone_encode:encode(Input))
+              ?assertEqual({ok, Expected}, jsone_encode:encode(Input))
       end},
      {"空オブジェクトがエンコード可能",
       fun () ->
               Input    = {[]},
               Expected = <<"{}">>,
-              ?assertEqual(Expected, jsone_encode:encode(Input))
+              ?assertEqual({ok, Expected}, jsone_encode:encode(Input))
       end},
      {"オブジェクトのメンバのキーにはバイナリのみが使用可能",
       fun () ->
-              ?assertError(badarg, jsone_encode:encode({[{1, 2}]})),
-              ?assertError(badarg, jsone_encode:encode({[{"1", 2}]})),
-              ?assertError(badarg, jsone_encode:encode({[{true, 2}]}))
+              ?assertMatch({error, {badarg, _}}, jsone_encode:encode({[{1, 2}]})),
+              ?assertMatch({error, {badarg, _}}, jsone_encode:encode({[{"1", 2}]})),
+              ?assertMatch({error, {badarg, _}}, jsone_encode:encode({[{true, 2}]}))
       end},
 
      %% その他
@@ -115,10 +115,10 @@ encode_test_() ->
       fun () ->
               Input    = [true, {[{<<"1">>, 2}, {<<"array">>, [[[[1]]], {[{<<"ab">>, <<"cd">>}]}, false]}]}, null],
               Expected = <<"[true,{\"1\":2,\"array\":[[[[1]]],{\"ab\":\"cd\"},false]},null]">>,
-              ?assertEqual(Expected, jsone_encode:encode(Input))
+              ?assertEqual({ok, Expected}, jsone_encode:encode(Input))
       end},
      {"不正な値",
       fun () ->
-              ?assertError(badarg, jsone_encode:encode(self()))
+              ?assertMatch({error, {badarg, _}}, jsone_encode:encode(self()))
       end}
     ].