-ifdef(TEST).

-ifndef(testing_hrl).

-define(testing_hrl, true).

-include("prop_testing.hrl").
-include_lib("eunit/include/eunit.hrl").

-compile(export_all).

-define(TEST_CASE(FunName), {atom_to_list(FunName), fun FunName/0}).
-define(LOOPER(Fun, Args, LoopTimeout, Count), 
        test_utils:state_sleep_looper(Fun, Args, LoopTimeout, Count)).
-define(WAIT_FOR_PROCESS_STOPPED(ProcessRegisteredNameOrID),
        test_utils:wait_for_process_stopped(ProcessRegisteredNameOrID)).
-define(MECK(Module, Funs), test_utils:meck_module(Module, Funs)).
-define(MECK_LOOP(Module, Funs), test_utils:meck_loop_module(Module, Funs)).
-define(MECK_RESET(Module), meck:reset(Module)).
-define(MECK_AND_RESET(Module, Funs), ?MECK(Module, Funs), meck:reset(Module)).
-define(UNMECK, test_utils:unmeck_modules()).
-define(UNMECK(Module), test_utils:unmeck_module(Module)).

-define(assertContains(Element, List), begin ((
    fun(E, L) ->
        case lists:member(E, L) of
            true -> ok;
            __V -> erlang:error({assert,
                [{module, ?MODULE},
                    {line, ?LINE},
                    {expected, L ++ [E]},
                    {value, L}]})
        end
    end
)(Element, List))end).

-define(assertContainsAll(Elements, List), begin ((
    fun(Es, L) ->
        case lists:all(fun(E) -> lists:member(E, L) end, Es) of
            true -> ok;
            __V -> erlang:error({assert,
                [{module, ?MODULE},
                    {line, ?LINE},
                    {expected, L ++ Es},
                    {value, L}]})
        end
    end
)(Elements, List))end).

-define(assertNotContains(Element, List), begin ((
        fun(E, L) ->
            case lists:member(E, L) of
                false -> ok;
                __V -> erlang:error({assert,
                    [{module, ?MODULE},
                        {line, ?LINE},
                        {expected, L -- [E]},
                        {value, L}]})
            end
        end
)(Element, List))end).


-define(SORT_PROPERTIES_IN_JSON(U), begin((
        fun
             SSort([FirstTuple | RestOfTuples]) when is_tuple(FirstTuple) ->
                 lists:sort(lists:merge([SSort(FirstTuple)], SSort(RestOfTuples)));

             SSort(ArrayOfElements) when is_list(ArrayOfElements) ->
                 [SSort(E) || E <- ArrayOfElements];

             SSort({AttrName, AttrValue}) when is_atom(AttrName) ->
                 SSort({atom_to_binary(AttrName, utf8), AttrValue});

             SSort({AttrName, AttrValue}) when is_integer(AttrName) ->
                 SSort({integer_to_binary(AttrName), AttrValue});

             SSort({AttrName, AttrValue}) ->
                 {AttrName, SSort(AttrValue)};

             SSort(Primitive) ->
                 Primitive
         end
))(U)end).

-define(assertJsonEqual(Expected, Actual), begin ((
    fun(E, A) ->
        StripWhitespaces = fun
              (Binary) when is_binary(Binary) ->
                  jsx:encode(?SORT_PROPERTIES_IN_JSON(jsx:decode(Binary)));
              (JSX) ->
                  jsx:encode(?SORT_PROPERTIES_IN_JSON(JSX))
          end,
        StripedE = StripWhitespaces(E),
        StripedA = StripWhitespaces(A),
        io:format("~nExpected: ~p", [StripedE]),
        io:format("~nActual  : ~p", [StripedA]),
        ?assertEqual(StripedE, StripedA)
    end
)(Expected, Actual))end).

-define(assertEqualUnordered(Expected, Actual), ?assertEqual(lists:sort(Expected), lists:sort(Actual))).
-define(assertNotEqualUnordered(Expected, Actual), ?assertNotEqual(lists:sort(Expected), lists:sort(Actual))).

-define(assertCalledOnce(Module, Function, Args), ?assertCalled(1, Module, Function, Args)).

-define(assertNotCalled(Module, Function), ?assertNotCalled(Module, Function, '_')).
-define(assertNotCalled(Module, Function, Args), ?assertCalled(0, Module, Function, Args)).

-define(assertCalled(NumCalls, ModuleName, FunctionName, ArgsList),
    (fun(Module, Function, Args) ->
        try ?assertEqual(NumCalls, meck:num_calls(Module, Function, Args)) of
            _ ->
                ok
        catch
            error:_ ->
                History = lists:filtermap(fun(Tuple) ->
                    {M, F, _A} = MFA = erlang:element(2, Tuple),
                    if M =:= Module andalso F =:= Function->
                        {true, MFA};
                    true ->
                        false
                    end
                end, meck:history(Module)),
                Expected =
                    case NumCalls of
                        0 ->
                            not_called;
                        _ ->
                            {Module, Function, Args}
                    end,
                ArgsStr =
                    if Args =:= '_' ->
                        "...";
                    true ->
                        string:join([io_lib:format("~p", [Arg]) || Arg <- Args], ",")
                    end,
                erlang:error({assert, [
                    {module, ?MODULE},
                    {line, ?LINE},
                    {matcher, lists:flatten(io_lib:format(
                        "~s:~s(~s) called ~p time(s)", [Module, Function, ArgsStr, NumCalls])
                    )},
                    {expected, Expected},
                    {actual, History}
                ]})
        end
    end)(ModuleName, FunctionName, ArgsList)
).

-endif.

-endif.