gj

-module(gj_decode_test).
-compile(no_auto_import).

-export([numbers_test/0, strings_test/0, objects_test/0, arrays_test/0, whitespace_test/0]).

numbers_test() ->
    assert_fail(<<"-"/utf8>>, unexpected_end_of_input),
    assert_fail(<<"--1"/utf8>>, {unexpected_token, <<"+"/utf8>>}),
    assert_fail(<<"01"/utf8>>, {unexpected_token, <<"1"/utf8>>}),
    assert_fail(<<".1"/utf8>>, {unexpected_token, <<"."/utf8>>}),
    assert_fail(<<"1."/utf8>>, unexpected_end_of_input),
    assert_fail(<<"1e"/utf8>>, unexpected_end_of_input),
    assert_fail(<<"1.0e+"/utf8>>, unexpected_end_of_input),
    assert_fail(<<"1e999"/utf8>>, invalid_number),
    assert_pass(<<"0"/utf8>>, {number, 0.0}),
    assert_pass(<<"1"/utf8>>, {number, 1.0}),
    assert_pass(<<"-0"/utf8>>, {number, 0.0}),
    assert_pass(<<"-1"/utf8>>, {number, -1.0}),
    assert_pass(<<"0.1"/utf8>>, {number, 0.1}),
    assert_pass(<<"-0.1"/utf8>>, {number, -0.1}),
    assert_pass(<<"0e0"/utf8>>, {number, 0.0}),
    assert_pass(<<"0E0"/utf8>>, {number, 0.0}),
    assert_pass(<<"1e0"/utf8>>, {number, 1.0}),
    assert_pass(<<"1E0"/utf8>>, {number, 1.0}),
    assert_pass(<<"1.0e0"/utf8>>, {number, 1.0}),
    assert_pass(<<"1e+0"/utf8>>, {number, 1.0}),
    assert_pass(<<"1.0e+0"/utf8>>, {number, 1.0}),
    assert_pass(<<"0.1e1"/utf8>>, {number, 1.0}),
    assert_pass(<<"0.1e-1"/utf8>>, {number, 0.01}),
    assert_pass(
        <<"99.99e99"/utf8>>,
        {number,
         99990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0}
    ),
    assert_pass(
        <<"-99.99e-99"/utf8>>,
        {number,
         -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009999}
    ),
    assert_pass(
        <<"123456789.123456789e123"/utf8>>,
        {number,
         123456789123456789000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0}
    ).

strings_test() ->
    assert_fail(<<"\""/utf8>>, unexpected_end_of_input),
    assert_fail(<<"\"\\\""/utf8>>, unexpected_end_of_input),
    assert_fail(<<"\"\\k\""/utf8>>, {unexpected_token, <<"k"/utf8>>}),
    assert_fail(<<"\"\\u2603\\\""/utf8>>, unexpected_end_of_input),
    assert_fail(
        <<"\"Here's a snowman for you: ☃. Good day!"/utf8>>,
        unexpected_end_of_input
    ),
    assert_fail(<<"\"𝄞"/utf8>>, unexpected_end_of_input),
    assert_fail(<<"\\u001F)"/utf8>>, {unexpected_token, <<"\\"/utf8>>}),
    assert_fail(<<"\"\\ud8aa\\udcxx\""/utf8>>, {unexpected_token, <<"x"/utf8>>}),
    assert_fail(<<"\"\\ud8aa\\uda00\""/utf8>>, invalid_unicode_sequence),
    assert_fail(<<"\"\\uxxxx\""/utf8>>, {unexpected_token, <<"x"/utf8>>}),
    assert_pass(
        <<"  \"\\n\\r\\t\\b\\/\\\\\"  "/utf8>>,
        {string, <<"\n\r\t\b\/\\"/utf8>>}
    ),
    assert_pass(<<"\"\\u2603\""/utf8>>, {string, <<"☃"/utf8>>}),
    assert_pass(<<"\"\\uD834\\uDD1E\""/utf8>>, {string, <<"𝄞"/utf8>>}),
    assert_pass(<<"\"\\uD799\\uD799\""/utf8>>, {string, <<"힙힙"/utf8>>}),
    assert_pass(<<"\"✔︎\""/utf8>>, {string, <<"✔︎"/utf8>>}).

objects_test() ->
    assert_fail(<<"{"/utf8>>, unexpected_end_of_input),
    assert_fail(<<"{,"/utf8>>, {unexpected_token, <<","/utf8>>}),
    assert_fail(<<"{\"foo\"}"/utf8>>, {unexpected_token, <<"}"/utf8>>}),
    assert_fail(
        <<"{\"foo\": \"bar\",}"/utf8>>,
        {unexpected_token, <<"}"/utf8>>}
    ),
    assert_pass(<<"{}"/utf8>>, {object, []}),
    assert_pass(
        <<"{\"foo\": \"bar\"}"/utf8>>,
        {object, [{<<"foo"/utf8>>, {string, <<"bar"/utf8>>}}]}
    ),
    assert_pass(
        <<"{\"foo\"  : \"bar\"}"/utf8>>,
        {object, [{<<"foo"/utf8>>, {string, <<"bar"/utf8>>}}]}
    ),
    Expected = {object,
                [{<<"foo"/utf8>>, {string, <<"bar"/utf8>>}},
                 {<<"baz"/utf8>>, {string, <<"quux"/utf8>>}}]},
    assert_pass(<<"{\"foo\": \"bar\", \"baz\": \"quux\"}"/utf8>>, Expected),
    Expected2 = {object,
                 [{<<"foo"/utf8>>,
                   {object, [{<<"bar"/utf8>>, {string, <<"baz"/utf8>>}}]}}]},
    assert_pass(<<"{\"foo\": {\"bar\": \"baz\"}}"/utf8>>, Expected2).

arrays_test() ->
    assert_fail(<<"["/utf8>>, unexpected_end_of_input),
    assert_fail(<<"[,"/utf8>>, {unexpected_token, <<","/utf8>>}),
    assert_fail(<<"[1,]"/utf8>>, {unexpected_token, <<"]"/utf8>>}),
    assert_pass(<<"[]"/utf8>>, {array, []}),
    assert_pass(
        <<"[1, 2, 3]"/utf8>>,
        {array, [{number, 1.0}, {number, 2.0}, {number, 3.0}]}
    ),
    assert_pass(
        <<"[\"foo\", \"bar\", \"baz\"]"/utf8>>,
        {array,
         [{string, <<"foo"/utf8>>},
          {string, <<"bar"/utf8>>},
          {string, <<"baz"/utf8>>}]}
    ),
    assert_pass(
        <<"[{\"foo\": \"bar\"}]"/utf8>>,
        {array, [{object, [{<<"foo"/utf8>>, {string, <<"bar"/utf8>>}}]}]}
    ).

whitespace_test() ->
    assert_fail(<<""/utf8>>, unexpected_end_of_input),
    assert_fail(<<"    "/utf8>>, unexpected_end_of_input),
    assert_pass(<<"  [  ]  "/utf8>>, {array, []}),
    assert_pass(<<"  {  }  "/utf8>>, {object, []}),
    assert_pass(
        <<"  [  1  ,  2  ,  3  ]  "/utf8>>,
        {array, [{number, 1.0}, {number, 2.0}, {number, 3.0}]}
    ),
    Expected = {object,
                [{<<"foo"/utf8>>, {string, <<"bar"/utf8>>}},
                 {<<"baz"/utf8>>, {string, <<"quux"/utf8>>}}]},
    assert_pass(
        <<"  {  \"foo\"  :  \"bar\"  ,  \"baz\"  :  \"quux\"  }  "/utf8>>,
        Expected
    ).

assert_pass(In, Out) ->
    gleam@should:equal(gj:decode(In), {ok, Out}).

assert_fail(In, Out) ->
    {error, {Err, _}} = gj:decode(In),
    gleam@should:equal(Err, Out).