anchor.diff:      W = fun(N) ->
           [Worker | _] = maps:get(lists:nth(N, lists:usort(ProvIDs0)), ProvMap),
           Worker
  -        end,
  +    end,
   
       User = <<"user1">>,
   
  
positive.code:     Workers = ?config(op_worker_nodes, Config),
      {Worker1, Worker2} = lists:foldl(fun(W, {Acc1, Acc2}) ->
          NAcc1 = case is_atom(Acc1) of
                      true ->
                          Acc1;
                      _ ->
                          case string:str(atom_to_list(W), "p1") of
                              0 -> Acc1;
                              _ -> W
                          end
                  end,
          NAcc2 = case is_atom(Acc2) of
                      true ->
                          Acc2;
                      _ ->
                          case string:str(atom_to_list(W), "p2") of
                              0 -> Acc2;
                              _ -> W
                          end
                  end,
          {NAcc1, NAcc2}
      end, {[], []}, Workers),
  
  
negative.code:     DirName = fun(N) ->
          NameSuffix = integer_to_binary(N),
          <<DirBaseName/binary, NameSuffix/binary>>
      end,
  
      AllFiles = lists:map(
          fun(N) ->
  
              Files = lists:foldl(fun
                  (10, retry) ->
                      throw(unable_to_make_concurrent_create);
                  (_, L) when is_list(L) ->
                      L;
                  (_, _) ->
                      lists:foreach(
                          fun(WId) ->
                              lfm_proxy:unlink(W(WId), SessId(W(WId)), {path, DirName(N)})
                          end, lists:seq(1, ProvIdCount)),
  
                      lists:foreach(
                          fun(WId) ->
                              spawn(fun() ->
                                  TestMaster ! {WId, lfm_proxy:mkdir(W(WId), SessId(W(WId)), DirName(N), 8#755)}
                              end)
                          end, lists:seq(1, ProvIdCount)),
  
                      try
                          lists:map(
                              fun(WId) ->
                                  receive
                                      {WId, {ok, GUID}} ->
                                          {WId, GUID};
                                      {WId, {error, _}} ->
                                          throw(not_concurrent)
                                  end
                              end, lists:seq(1, ProvIdCount))
                      catch
                          not_concurrent ->
                              retry
                      end
  
  
              end, start, lists:seq(1, 10)),
              {N, Files}
          end, lists:seq(1, FileCount)),
  
      ct:print("AllFiles ~p", [AllFiles]),
      {_, IdsPerWorker} = lists:unzip(AllFiles),
      Ids = [GUID || {_, GUID} <- lists:flatten(IdsPerWorker)],
      ExpectedIds = lists:usort(Ids),
  
      lists:foreach(
          fun(WId) ->
              Check = fun() ->
                  {ok, CL} = lfm_proxy:ls(W(WId), SessId(W(WId)), {path, SpaceName}, 0, 1000),
                  ExpectedChildCount = ProvIdCount * FileCount,
                  {FetchedIds, FetchedNames} = lists:unzip(CL),
  
  %%                ct:print("Check ~p", [{lists:usort(Ids), lists:usort(FetchedIds)}]),
  %%                ct:print("Check ~p", [{ExpectedChildCount, CL}]),
  
                  {length(CL), length(lists:usort(FetchedNames)), lists:usort(FetchedIds)}
              end,
              ?assertMatch({ExpectedChildCount, ExpectedChildCount, ExpectedIds}, Check(), 15),
  
              {ok, ChildList} = lfm_proxy:ls(W(WId), SessId(W(WId)), {path, SpaceName}, 0, 1000),
              lists:foreach(
                  fun(FileNo) ->
                      LocalIdsPerWorker = proplists:get_value(FileNo, AllFiles),
                      LocalGUID = proplists:get_value(WId, lists:flatten(LocalIdsPerWorker)),
                      LocalName = proplists:get_value(LocalGUID, ChildList),
                      ExpectedName = filename:basename(DirName(FileNo)),
  %%                    ct:print("Local name test ~p", [{FileNo, LocalGUID, ExpectedName, LocalName}]),
  
                      ?assertMatch(ExpectedName, LocalName)
                  end, lists:seq(1, FileCount))
  