anchor.diff:  %% @end
   %%--------------------------------------------------------------------
   -spec prepare_to_write(Input :: term()) -> tuple().
  -prepare_to_write(Input) when is_list(Input) ->
  +prepare_to_write({struct, List}) ->
  +  prepare_to_write(List);
  +
  +prepare_to_write([{_,_} | _] = 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}.+  {K, V};
  +
  +prepare_to_write(Any) ->
  +  Any.
positive.code:             {config_extension, Ext},
              {repeats, Repeats},
              {ok_counter, OkNum},
              {results, {struct, Values}},
              {errors, Errors}
            ]
          }
  
negative.code: 
  %%--------------------------------------------------------------------
  %% @doc
  %% Executes test configuration many times. Returns [ValuesSums, ValuesLists, OkNum, Errors].
  %% @end
  %%--------------------------------------------------------------------
  -spec exec_multiple_tests(M :: atom(), F :: atom(), Inputs :: list(), Count :: integer()) -> list().
  exec_multiple_tests(M, F, Inputs, Count) ->
    exec_multiple_tests(M, F, Inputs, Count, [], [], 0, []).
  
  exec_multiple_tests(_M, _F, _Inputs, 0, ValuesSums, ValuesLists, OkNum, Errors) ->
    ReversedValuesLists = lists:map(fun({K, Val}) ->
      {K, lists:reverse(Val)}
    end, ValuesLists),
    [ValuesSums, ReversedValuesLists, OkNum, lists:reverse(Errors)];
  
  exec_multiple_tests(M, F, Inputs, Count, ValuesSums, ValuesLists, OkNum, Errors) ->
    case exec_test(M, F, Inputs) of
      {error, E} ->
        exec_multiple_tests(M, F, Inputs, Count - 1, ValuesSums, ValuesLists, OkNum, [E | Errors]);
      V ->
        case ValuesSums of
          [] ->
            InitValuesLists = lists:map(fun({K, Val}) ->
              {K, [Val]}
            end, V),
            exec_multiple_tests(M, F, Inputs, Count - 1, V, InitValuesLists, OkNum + 1, Errors);
          _ ->
            NewVSums = lists:zipwith(fun({K, V1}, {K, V2}) ->
              {K, V1 + V2}
            end, V, ValuesSums),
            NewVLists = lists:zipwith(fun({K, V1}, {K, V2}) ->
              {K, [V1 | V2]}
            end, V, ValuesLists),
            exec_multiple_tests(M, F, Inputs, Count - 1, NewVSums, NewVLists, OkNum + 1, Errors)
        end
    end.
  
  