anchor.diff:  
   %%%===================================================================
   %%% Internal functions
  -%%%===================================================================+%%%===================================================================
  +
  +exec_and_check_time(Mod, M, A) ->
  +    BeforeProcessing = os:timestamp(),
  +    Ans = erlang:apply(Mod, M, A),
  +    AfterProcessing = os:timestamp(),
  +    {Ans, timer:now_diff(AfterProcessing, BeforeProcessing)}.
  +
  +create_deep_tree(Worker) ->
  +    create_deep_tree(Worker, "/spaces/Space 1", 18).
  +
  +create_deep_tree(Worker, Prefix, 1) ->
  +    {{A, U}, Time} = ?call_with_time(Worker, create, [{path, list_to_binary(Prefix)}, #file_meta{name = <<"1">>}]),
  +    ?assertMatch({ok, _}, {A, U}),
  +    {list_to_binary(Prefix++"/1"), Time};
  +
  +create_deep_tree(Worker, Prefix, Num) ->
  +    StringNum = integer_to_list(Num),
  +    {A, U} = ?call(Worker, create, [{path, list_to_binary(Prefix)}, #file_meta{name = list_to_binary(StringNum)}]),
  +    ?assertMatch({ok, _}, {A, U}),
  +    create_deep_tree(Worker, Prefix++"/"++StringNum, Num-1).
  
positive.code:     ?assertMatch({ok, _}, {A22, U22}),
      ?assertMatch({ok, _}, {A23, U23}),
  
  
      Bench1 =
          fun Loop(File) when File < 100 ->
              ?assertMatch({ok, _}, ?call(Worker1, create, [{path, <<"/spaces/Space 1/dir1">>}, #file_meta{name = integer_to_binary(1000 + File)}])),
              Loop(File + 1);
              Loop(_) ->
                  ok
          end,
  
      S1 = now(),
      Bench1(0),
      E1 = now(),
  
      {A14, U14} = ?call(Worker1, get, [{path, <<"/">>}]),
      {A5, U5} = ?call(Worker1, get, [{path, <<"/spaces">>}]),
      {A6, U6} = ?call(Worker2, get, [{path, <<"/spaces/Space 1">>}]),
      {A7, U7} = ?call(Worker1, get, [{path, <<"/spaces/Space 1/dir1">>}]),
      {A8, U8} = ?call(Worker2, get, [{path, <<"/spaces/Space 1/dir1/file1">>}]),
      ?assertMatch({ok, #document{value = #file_meta{name = <<"">>}}},        {A14, U14}),
  
negative.code:     ?assertMatch({ok, #document{key = U2}},             {A12, U12}),
      ?assertMatch({ok, #document{key = U2}},             {A13, U13}),
  
      {{AL20_3, UL20_3}, GetScopeLevel20} = ?call_with_time(Worker2, get_scope, [UL20]),
      ?assertMatch({ok, #document{key = U2}},             {AL20_3, UL20_3}),
  
      ?assertMatch({ok, [U2]}, ?call(Worker1, list_uuids, [{path, <<"/spaces">>}, 0, 10])),
  
      {{A15, U15}, ListUuids20_100} = ?call_with_time(Worker1, list_uuids, [{path, <<"/spaces/Space 1/dir1">>}, 0, 20]),
      {{A15_2, U15_2}, ListUuids100_100} = ?call_with_time(Worker1, list_uuids, [{path, <<"/spaces/Space 1/dir1">>}, 0, 100]),
      {{A15_3, U15_3}, ListUuids1000_100} = ?call_with_time(Worker1, list_uuids, [{path, <<"/spaces/Space 1/dir1">>}, 0, 1000]),
      {{A15_4, U15_4}, ListUuids1_100} = ?call_with_time(Worker1, list_uuids, [{path, <<"/spaces/Space 1/dir1">>}, 0, 1]),
      {{A16, U16}, ListUuids50_60_100} = ?call_with_time(Worker1, list_uuids, [{path, <<"/spaces/Space 1/dir1">>}, 50, 10]),
      {{AL20_4, UL20_4}, ListUuidsLevel20} = ?call_with_time(Worker1, list_uuids, [{path, Level20Path}, 0, 1]),
  
      ?assertMatch({ok, _}, {A15, U15}),
      ?assertMatch({ok, _}, {A15_2, U15_2}),
      ?assertMatch({ok, _}, {A15_3, U15_3}),
      ?assertMatch({ok, _}, {A15_4, U15_4}),
      ?assertMatch({ok, _}, {A16, U16}),
      ?assertMatch({ok, _}, {AL20_4, UL20_4}),
  
      ?assertMatch(20, length(U15)),
      ?assertMatch(100, length(U15_2)),
      ?assertMatch(100, length(U15_3)),
      ?assertMatch(1, length(U15_4)),
      ct:print("~p~n~p", [U16, lists:sublist(U15_2, 51, 10)]),
      ?assertMatch(U16, lists:sublist(U15_2, 51, 10)),
      ?assertMatch(0, length(UL20_4)),
  
      {AE1, ExistsFalseLevel4} = ?call_with_time(Worker1, exists, [{path, <<"/spaces/Space 1/dir2/file4">>}]),
      ?assertMatch(false, AE1),
      ?assertMatch(false, ?call(Worker1, exists, [{path, <<"/spaces/Space 2/dir2/file1">>}])),
      {AE2, ExistsTrueLevel1} = ?call_with_time(Worker1, exists, [{path, <<"/">>}]),
      ?assertMatch(true, AE2),
      {AE3, ExistsTrueLevel4} = ?call_with_time(Worker1, exists, [{path, <<"/spaces/Space 1/dir2/file1">>}]),
      ?assertMatch(true, AE3),
      {AE4, ExistsTrueLevel20} = ?call_with_time(Worker1, exists, [{path, Level20Path}]),
      ?assertMatch(true, AE4),
      ?assertMatch({ok, [_, _, _]}, ?call(Worker1, list_uuids, [{path, <<"/spaces/Space 1/dir2">>}, 0, 10])),
  
      {AD1, DeleteOkPathLevel4} = ?call_with_time(Worker1, delete, [{path, <<"/spaces/Space 1/dir2/file1">>}]),
      ?assertMatch(ok, AD1),
      {AD2, DeleteOkUuidLevel4} = ?call_with_time(Worker1, delete, [{uuid, U22}]),
      ?assertMatch(ok, AD2),
      {AD3, DeleteErrorPathLevel4} = ?call_with_time(Worker1, delete, [{path, <<"/spaces/Space 1/dir2/file4">>}]),
      ?assertMatch({error, _}, AD3),
      {AD4, DeleteOkPathLevel20} = ?call_with_time(Worker1, delete, [{path, Level20Path}]),
      ?assertMatch(ok, AD4),
  
      ?assertMatch(false, ?call(Worker1, exists, [{path, <<"/spaces/Space 1/dir2/file1">>}])),
      ?assertMatch(false, ?call(Worker1, exists, [{path, <<"/spaces/Space 1/dir2/file2">>}])),
  
      ?assertMatch({ok, [U23]}, ?call(Worker1, list_uuids, [{path, <<"/spaces/Space 1/dir2">>}, 0, 10])),
  
      ok.
  
  