anchor.diff:      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).
  +    lists:foreach(fun(Model) ->
  +        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])),
  +            perform_infinite_log_appends(Worker, Model, LogId, LogSize, 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"
  +                                "model:                  ~p~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"
  +                                "efficiency:             ~p [listings/s]",
  +                                    [Model, ProcCount, ListingsPerProcess, LogSize, MaxEntriesPerNode, SizePruningThreshold,
  +                                        AgePruningThreshold, ListingDirection, ListingStartFromParsed, ListingOffset,
  +                                        ListingLimit, 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)
  +    end, Models).
   
   
   %%%===================================================================
  
positive.code:         lists:sum(AppendTimes) / ProcCount
      end, lists:seq(1, Repeats)),
      lists:sum(Results) / Repeats.
  
negative.code:     ct:timetrap({hours, 3}),
      Repeats = ?config(repeats, Config),
      [Worker | _] = ?config(cluster_worker_nodes, Config),
      Models = ?config(models, Config),
  
      ProcCountList = ?config(proc_count_list, Config),
      AppendsCount = ?config(appends_count, Config),
      LogSize = 100,
  
      MaxEntriesPerNodeList = ?config(max_entries_per_node_list, Config),
      SizePruningThreshold = ?config(size_pruning, Config),
      AgePruningThreshold = ?config(age_pruning, Config),
  
      lists:foreach(fun(Model) ->
          lists:foreach(fun(ProcCount) ->
              lists:foreach(fun(MaxEntriesPerNode) ->
                  AppendsPerProcess = AppendsCount div ProcCount,
                  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])),
                  AvgTime = repeat_infinite_log_appends(Repeats, Worker, Model, LogId, LogSize, ProcCount, AppendsPerProcess),
                  ?assertMatch(ok, rpc:call(Worker, Model, infinite_log_destroy, [LogId])),
                  ct:pal("Results for infinite log append tests:\n"
                  "model:                  ~p~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"
                  "efficiency:             ~p [appends/s]",
                      [Model, ProcCount, AppendsPerProcess, LogSize, MaxEntriesPerNode, SizePruningThreshold, AgePruningThreshold,
                          AppendsCount / AvgTime * 1000])
              end, MaxEntriesPerNodeList)
          end, ProcCountList)
      end, Models).
  
  
  infinite_log_list_performance_test(Config) ->
  