anchor.diff:  %%--------------------------------------------------------------------
   -spec check_links() -> ok | {error, term()}.
   check_links() ->
  -  receive
  -    {'EXIT', _, normal} ->
  -      check_links();
  -    {'EXIT',_,_} ->
  -      {error, linked_proc_error}
  -  after 0 ->
  -    ok
  -  end.
  +    receive
  +        {'EXIT', _, normal} ->
  +            check_links();
  +        {'EXIT', _, _} ->
  +            {error, linked_proc_error}
  +    after 0 ->
  +        ok
  +    end.
   
   %%--------------------------------------------------------------------
   %% @doc
  
positive.code: %%--------------------------------------------------------------------
  -spec exec_test(M :: atom(), F :: atom(), Inputs :: list()) -> list() | {error, term()}.
  exec_test(M, F, Inputs) ->
    try
      BeforeProcessing = os:timestamp(),
      Ans = annotation:call_advised(M, F, Inputs),
      AfterProcessing = os:timestamp(),
      case check_links() of
        ok ->
          TestTime = timer:now_diff(AfterProcessing, BeforeProcessing),
          case Ans of
            {K, V} when is_number(V) ->
              [{test_time, TestTime}, {K, V}];
            AnsList when is_list(AnsList) ->
              lists:foldl(fun(AnsPart, Acc) ->
                case AnsPart of
                  {K2, V2} when is_number(V2) ->
                    [{K2, V2} | Acc];
                  _ ->
                    Acc
                end
              end, [{test_time, TestTime}], AnsList);
            _ ->
              [{test_time, TestTime}]
          end;
        E ->
          E
      end
    catch
      E1:E2 ->
        {error, {E1, E2, erlang:get_stacktrace()}}
    end.
  
  %%--------------------------------------------------------------------
  %% @doc
  
negative.code: %% @end
  %%--------------------------------------------------------------------
  -spec prepare_to_write(Input :: term()) -> tuple().
  prepare_to_write({struct, List}) ->
      prepare_to_write(List);
  
  prepare_to_write(Input) when is_list(Input) ->
      {struct, lists:map(fun(I) -> prepare_to_write(I) end, Input)};
  
  prepare_to_write({K, V}) when is_list(V) ->
      {K, prepare_to_write(V)};
  
  prepare_to_write({K, V}) ->
      {K, V}.
  