anchor.diff:      Workers = ?config(cluster_worker_nodes, Config),
       Expiry = ?config(expiry, Config),
       test_utils:set_env(Workers, cluster_worker, link_disk_expiry, Expiry),
  -
       test_utils:mock_unload(Workers, links_tree);
   end_per_testcase(link_del_should_delay_inactivate, Config) ->
       Workers = ?config(cluster_worker_nodes, Config),
  
positive.code:     ListingLimitList = ?config(listing_limit_list, Config),
      AppendProcessesCount = 500,
  
      lists:foreach(fun(MaxEntriesPerNode) ->
          LogId = str_utils:rand_hex(10),
          LogOpts = #{
              max_entries_per_node => MaxEntriesPerNode,
              size_pruning_threshold => SizePruningThreshold,
              age_pruning_threshold => AgePruningThreshold
          },
          ?assertMatch(ok, rpc:call(Worker, Model, infinite_log_create, [LogId, LogOpts])),
          Log = str_utils:rand_hex(LogSize div 2),
          perform_infinite_log_appends(Worker, Model, LogId, Log, AppendProcessesCount, AppendsCount div AppendProcessesCount),
  
          lists:foreach(fun(ListingDirection) ->
              lists:foreach(fun(ListingStartFrom) ->
                  lists:foreach(fun(ListingOffset) ->
                      lists:foreach(fun(ListingLimit) ->
                          lists:foreach(fun(ProcCount) ->
                              ListingsPerProcess = ListingsCount div ProcCount,
  
                              ListingStartFromParsed = case is_map(ListingStartFrom) of
                                  true -> {hd(maps:keys(ListingStartFrom)), hd(maps:values(ListingStartFrom))};
                                  false -> undefined
                              end,
  
                              ListOpts = #{
                                  direction => ListingDirection,
                                  start_from => ListingStartFromParsed,
                                  offset => ListingOffset,
                                  limit => ListingLimit
                              },
                              AvgTime = repeat_infinite_log_listings(Repeats, Worker, Model, LogId, ListOpts, ProcCount, ListingsPerProcess),
  
                              ct:pal("Results for infinite log list tests:\n"
                              "process count:          ~p~n"
                              "process repeats:        ~p~n"
                              "log size:               ~p~n"
                              "max entries per node:   ~p~n"
                              "size pruning threshold: ~p~n"
                              "age pruning threshold:  ~p~n"
                              "list direction:         ~p~n"
                              "list starting from:     ~p~n"
                              "offset:                 ~p~n"
                              "limit:                  ~p~n"
                              "time:                   ~p [ms]~n"
                              "efficiency:             ~p [listings/s]"
                                  , [ProcCount, ListingsPerProcess, LogSize, MaxEntriesPerNode, SizePruningThreshold, AgePruningThreshold,
                                      ListingDirection, ListingStartFromParsed, ListingOffset, ListingLimit,
                                      AvgTime, 1000 * ProcCount * ListingsPerProcess / AvgTime])
                          end, ProcCountList)
                      end, ListingLimitList)
                  end, ListingOffsetList)
              end, ListingStartFromList)
          end, ListingDirectionList),
          ?assertMatch(ok, rpc:call(Worker, Model, infinite_log_destroy, [LogId]))
      end, MaxEntriesPerNodeList).
  
  
  %%%===================================================================
  
negative.code:         {description, "List from infinite-log testcase"},
          {parameters, [
              [{name, repeats}, {value, 5}, {description, "Repeats of each listing test."}],
              [{name, models}, {value, [ets_only_model, ets_cached_model]}, {description, "Model used for tests"}],
              [{name, listing_direction_list}, {value, [backward_from_newest, forward_from_oldest]}, {description, "Listing directions to be tested."}],
              [{name, listing_start_from_list}, {value, [undefined, #{index => 3000}, #{timestamp => 100}]}, {description, "Starting from options to be tested."}],
              [{name, listing_offset_list}, {value, [0, 5000]}, {description, "Listing offsets to be tested."}],
  