anchor.diff:      Workers = ?config(op_worker_nodes, Config),
       ProvIDs0 = lists:map(fun(Worker) ->
           rpc:call(Worker, oneprovider, get_provider_id, [])
  -                         end, Workers),
  +    end, Workers),
   
       ProvIdCount = length(lists:usort(ProvIDs0)),
   
  
positive.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]),
  
      timer:sleep(10000),
  
      lists:foreach(
          fun(WId) ->
              {ok, ChildList} = lfm_proxy:ls(W(WId), SessId(W(WId)), {path, SpaceName}, 0, 1000),
              ExpectedChildCount = ProvIdCount * FileCount,
              {FetchedIds, FetchedNames} = lists:unzip(ChildList),
              {_, IdsPerWorker} = lists:unzip(AllFiles),
              Ids = [GUID || {_, GUID} <- lists:flatten(IdsPerWorker)],
              ExpectedIds = lists:usort(Ids),
  
              ct:print("Check ~p", [{lists:usort(Ids), lists:usort(FetchedIds)}]),
  
              ?assertMatch(ExpectedChildCount, length(ChildList)),
              ?assertMatch(ExpectedChildCount, length(lists:usort(FetchedNames))),
              ?assertMatch(ExpectedIds, lists:usort(FetchedIds)),
  
              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))
  
negative.code:     W = fun(N) ->
          [Worker | _] = maps:get(lists:nth(N, lists:usort(ProvIDs0)), ProvMap),
          Worker
      end,
  
      User = <<"user1">>,
  
  