anchor.diff:                  Level2File = <<Dir/binary, "/", (generator:gen_name())/binary>>,
                   Level2File2 = <<Dir/binary, "/", (generator:gen_name())/binary>>,
                   create_big_file(Config, ChunkSize, ChunksNum, PartNum, Level2File, Worker1),
  +                erlang:garbage_collect(),
   
                   T1 = lists:max(verify_workers(Workers2, fun(W) ->
                       read_big_file(Config, FileSize, Level2File, W, Transfer)
  -                end)),
  +                end, timer:minutes(5), not Transfer)),
                   T2 = lists:max(verify_workers(Workers3, fun(W) ->
                       read_big_file(Config, FileSize, Level2File, W, Transfer)
  -                end)),
  +                end, timer:minutes(5), not Transfer)),
   
                   create_big_file(Config, ChunkSize, ChunksNum, PartNum, Level2File2, Worker1),
  -                T3 = lists:max(verify(Config, fun(W) ->
  +                erlang:garbage_collect(),
  +                T3 = lists:max(verify_workers(Workers, fun(W) ->
                       read_big_file(Config, FileSize, Level2File2, W, Transfer)
  -                end)),
  +                end, timer:minutes(5), not Transfer)),
   
                   Master ! {slave_ans, ChunksNum, PartNum, Transfer, {ok, lists:max([T1, T2, T3])}}
               catch
  
positive.code:     Attempts = ?config(attempts, Config),
      read_big_file_loop(FileSize, File, Worker, SessId, Attempts, undefined, 0).
  
  read_big_file_loop(_FileSize, _File, _Worker, _SessId, _, {{ok, _Time, true}, ok}, TimeSum) ->
      TimeSum;
  read_big_file_loop(_FileSize, _File, _Worker, _SessId, 0, LastAns, _TimeSum) ->
      LastAns;
  read_big_file_loop(FileSize, File, Worker, SessId, Attempts, _LastAns, TimeSum) ->
      Ans = case lfm_proxy:open(Worker, SessId(Worker), {path, File}, rdwr) of
          {ok, Handle} ->
              ReadAns = try
                  Start = os:timestamp(),
                  {ok, Bytes} = lfm_proxy:read(Worker, Handle, 0, FileSize),
                  {ok, timer:now_diff(os:timestamp(), Start), FileSize == size(Bytes)}
              catch
                  E1:E2 ->
                      {read, E1, E2}
              end,
  
              {ReadAns, lfm_proxy:close(Worker, Handle)};
          OpenError ->
              {open_error, OpenError}
      end,
      case Ans of
          {{ok, Time, true}, _} ->
              read_big_file_loop(FileSize, File, Worker, SessId, Attempts - 1,
                  Ans, TimeSum + Time);
          _ ->
  
negative.code: 
      lists:map(fun({_W, Ans}) -> Ans end, TestAns).
  
  verify_helper([], _TestFun, _, _SpawnOnWorker) ->
      [];
  verify_helper([W | Workers], TestFun, Timeout, SpawnOnWorker) ->
      Master = self(),
      Pid = case SpawnOnWorker of
          true ->
              spawn_link(W, fun() ->
                  Ans = TestFun(W),
                  Master ! {verify_ans, W, Ans}
              end);
          _ ->
              spawn_link(fun() ->
                  Ans = TestFun(W),
                  Master ! {verify_ans, W, Ans}
              end)
      end,
      TmpAns = verify_helper(Workers, TestFun, Timeout, SpawnOnWorker),
      receive
          {verify_ans, W, TestAns} ->
              [{W, TestAns} | TmpAns];
  