anchor.diff:          {success_rate, ?SUCCESS_RATE},
           {description, "List from infinite-log testcase"},
           {parameters, [
  -            [{name, repeats}, {value, 3}, {description, "Repeats of each listing test."}],
  +            [{name, repeats}, {value, 5}, {description, "Repeats of each listing test."}],
               [{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."}],
  
positive.code:     ListingsCount = ?config(listings_count, Config),
  
      % Log options
      LogId = str_utils:rand_hex(10),
      LogSize = ?config(log_size, Config),
      AppendsCount = ?config(appends_count, Config),
      MaxEntriesPerNode = ?config(max_entries_per_node, Config),
      SizePruningThreshold = ?config(size_pruning_threshold, Config),
      AgePruningThreshold = ?config(age_pruning_threshold, Config),
      LogOpts = #{
          max_entries_per_node => MaxEntriesPerNode,
          size_pruning_threshold => SizePruningThreshold,
          age_pruning_threshold => AgePruningThreshold
      },
  
      % Listing options
      ListingDirectionList = ?config(listing_direction_list, Config),
      ListingStartFromList = ?config(listing_start_from_list, Config),
      ListingOffsetList = ?config(listing_offset_list, Config),
      ListingLimitList = ?config(listing_limit_list, Config),
  
      AppendProcessesCount = 500,
      ?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(ProcCount) ->
          lists:foreach(fun(ListingDirection) ->
              lists:foreach(fun(ListingStartFrom) ->
                  lists:foreach(fun(ListingOffset) ->
                      lists:foreach(fun(ListingLimit) ->
                          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"
                          "append 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, ListingLimitList)
                  end, ListingOffsetList)
              end, ListingStartFromList)
          end, ListingDirectionList)
      end, ProcCountList),
      ?assertMatch(ok, rpc:call(Worker, Model, infinite_log_destroy, [LogId])).
  
  
  %%%===================================================================
  
negative.code:                 size_pruning_threshold => SizePruningThreshold,
                  age_pruning_threshold => AgePruningThreshold
              },
              Log = str_utils:rand_hex(LogSize div 2),
              ?assertMatch(ok, rpc:call(Worker, Model, infinite_log_create, [LogId, LogOpts])),
              AvgTime = repeat_infinite_log_appends(Repeats, Worker, Model, LogId, Log, ProcCount, AppendsPerProcess),
              ?assertMatch(ok, rpc:call(Worker, Model, infinite_log_destroy, [LogId])),
              ct:pal("Results for infinite log append tests:\n"
              "process count:            ~p~n"
  