anchor.diff:          AfterProcessing = os:timestamp(),
           case check_links() of
               ok ->
  -                TestTime = timer:now_diff(AfterProcessing, BeforeProcessing),
  +                TestTime = round(timer:now_diff(AfterProcessing, BeforeProcessing) / 1000),
                   case Ans of
  -                    {K, V} when is_number(V) ->
  -                        [{test_time, TestTime}, {K, V}];
  +                    {K, V, U} when is_number(V) ->
  +                        [{test_time, TestTime, ms}, {K, V, U}];
                       AnsList when is_list(AnsList) ->
                           lists:foldl(fun(AnsPart, Acc) ->
                               case AnsPart of
  -                                {K2, V2} when is_number(V2) ->
  -                                    [{K2, V2} | Acc];
  +                                {K2, V2, U2} when is_number(V2) ->
  +                                    [{K2, V2, U2} | Acc];
                                   _ ->
                                       Acc
                               end
  -                        end, [{test_time, TestTime}], AnsList);
  +                        end, [{test_time, TestTime, ms}], AnsList);
                       _ ->
  -                        [{test_time, TestTime}]
  +                        [{test_time, TestTime, ms}]
                   end;
               E ->
                   E
  
positive.code:     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
  
negative.code:                         {config_extension, Ext},
                          {repeats, Repeats},
                          {ok_counter, OkNum},
                          {results_sums, [
                              {K, [
                                  {unit, U},
                                  {sum, S}
                              ]} || {K, S, U} <- ValuesSums]},
                          {results_lists, [
                              {K, [
                                  {unit, U},
                                  {list, L}
                              ]} || {K, L, U} <- ValuesLists]},
                          {errors, Errors}
                      ]
                  }
  