}

        @ParameterizedTest
        @DisplayName("Should handle various capacity and free space values")
        @CsvSource({ "0, 0", "1024, 512", "1048576, 524288", "1073741824, 536870912", "9223372036854775807, 4611686018427387903", // Long.MAX_VALUE and half
                "-1, -1", // Negative values (edge case)
                "100, 200" // Free space greater than capacity (edge case)
        })

  MapIteratorCache(Map<K, V> backingMap) {
    this.backingMap = checkNotNull(backingMap);
  }

  @CanIgnoreReturnValue
  final @Nullable V put(K key, V value) {
    checkNotNull(key);
    checkNotNull(value);
    clearCache();
    return backingMap.put(key, value);
  }

  @CanIgnoreReturnValue
  final @Nullable V remove(Object key) {
    checkNotNull(key);
    clearCache();
    return backingMap.remove(key);
  }

MinIO server allows to throttle incoming requests:

- limit the number of active requests allowed across the cluster
- limit the wait duration for each request in the queue

These values are enabled using server's configuration or environment variables.

## Examples

### Configuring connection limit

   * of their elements."
   *
   * </blockquote>
   */
  RESTRICTS_ELEMENTS,

  /**
   * Indicates that a collection has a well-defined ordering of its elements. The ordering may
   * depend on the element values, such as a {@link SortedSet}, or on the insertion ordering, such
   * as a {@link LinkedHashSet}. All list tests and sorted-collection tests automatically specify
   * this feature.
   */
  KNOWN_ORDER,

  /**

      // Create a copy of that, with the desired value for each value
      Collection<Entry<K, V>> entries = new ArrayList<>(elements.length);
      int i = 0;
      for (Entry<K, V> entry : originalEntries) {
        entries.add(mapEntry(entry.getKey(), valuesArray[i++]));
      }

      return mapGenerator.create(entries.toArray()).values();
    }

    @Override
    public V[] createArray(int length) {

            @Override
            public int getLtrWindowSize() {
                return 50;
            }
        });

        Map<String, Object> params = new HashMap<>();
        params.put("param1", "value1");

        RescorerBuilder<?> result = ltrQueryRescorer.evaluate(params);
        assertNull(result);
    }

    public void test_evaluate_withNullModelName() {
        // Test when model name is null

  @ParametricNullness
  public V getValue() {
    return delegate().getValue();
  }

  @Override
  @ParametricNullness
  @CanIgnoreReturnValue
  public V setValue(@ParametricNullness V value) {
    return delegate().setValue(value);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    return delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();

   * @param value the value to write
   */
  static void store64(byte[] sink, int offset, long value) {
    // We don't want to assert in production code.
    assert offset >= 0 && offset + 8 <= sink.length;
    // Delegates to the fast (unsafe)version or the fallback.
    byteArray.putLongLittleEndian(sink, offset, value);
  }

  /**
   * Load 4 bytes from the provided array at the indicated offset.
   *

    /**
     * The name of the request header.
     */
    @Required
    @Size(max = 100)
    public String name;

    /**
     * The value of the request header.
     */
    @Required
    @Size(max = 1000)
    public String value;

    /**
     * The web configuration ID associated with this request header.
     */
    @Required
    @Size(max = 1000)
    public String webConfigId;

    assertFalse(segment.containsKey(key, hash));
    assertFalse(segment.containsValue(value));

    // count == 1
    segment.count++;
    assertSame(value, segment.get(key, hash));
    assertTrue(segment.containsKey(key, hash));
    assertTrue(segment.containsValue(value));
    // don't see absent values now that count > 0
    assertNull(segment.get(new Object(), hash));

    // null key