stopwatch.sleepMillis(1000); // max capacity reached
    stopwatch.sleepMillis(1000); // this makes no difference
    limiter.acquire(1); // R0.00, since it's the first request

    limiter.acquire(1); // R0.00, from capacity
    limiter.acquire(3); // R0.00, from capacity
    limiter.acquire(1); // R0.00, concluding a burst of 5 permits

    limiter.acquire(); // R0.20, capacity exhausted
    assertEvents(

        map = new CaseInsensitiveMap<>(Math.max((int) (c.size() / .75f) + 1, 16));
        addAll(c);
    }

    /**
     * Creates a {@link CaseInsensitiveSet}.
     *
     * @param initialCapacity the initial capacity
     */
    public CaseInsensitiveSet(final int initialCapacity) {
        map = new CaseInsensitiveMap<>(initialCapacity);
    }

    @Override
    public Iterator<String> iterator() {

  }

  /**
   * Creates a {@code ObjectCountLinkedHashMap} instance, with a high enough "initial capacity" that
   * it <i>should</i> hold {@code expectedSize} elements without growth.
   *
   * @param expectedSize the number of elements you expect to add to the returned set
   * @return a new, empty {@code ObjectCountLinkedHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing

        public String key;
        /** Number of buffers */
        public long count;
        /** Used memory in bytes */
        public long used;
        /** Total capacity in bytes */
        public long capacity;
    }

    /**
     * Data transfer object representing JVM garbage collection statistics.
     */
    public static class JvmGcObj {
        /**
         * Default constructor.

   * Contention and/or table collisions are indicated by failed
   * CASes when performing an update operation (see method
   * retryUpdate). Upon a collision, if the table size is less than
   * the capacity, it is doubled in size unless some other thread
   * holds the lock. If a hashed slot is empty, and lock is
   * available, a new Cell is created. Otherwise, if the slot

        // Subsequent get should still work
        assertEquals(4, impl.getBuffer().length);
    }

    // Capacity behavior: when full, additional releases are dropped; only cached buffers are returned
    @Test
    @DisplayName("Cache capacity respected: extra releases dropped; retrieval order by first free slot")
    void cacheCapacityAndRetrievalOrder() {

 *       {@link NdrBuffer} so that the correct method is called with
 *       the correct argument.</li>
 *   <li>passing {@code null} throws {@link NullPointerException}.
 * </ul>
 *
 * The buffer is created with enough capacity for a 64‑bit value.
 */
@ExtendWith(MockitoExtension.class)
public class NdrHyperTest {

    /**
     * Tests a simple round‑trip encode → decode retains the original value.
     */
    @Test

	// Parameters:
	//   key: The key associated with the Stmt object to be deleted.
	Delete(key string)
}

// defaultMaxSize defines the default maximum capacity of the cache.
// Its value is the maximum value of the int64 type, which means that when the cache size is not specified,
// the cache can theoretically store as many elements as possible.

   * @throws IllegalArgumentException if {@code initialCapacity} is negative
   * @throws IllegalStateException if an initial capacity was already set
   */
  @CanIgnoreReturnValue
  public MapMaker initialCapacity(int initialCapacity) {
    checkState(
        this.initialCapacity == UNSET_INT,
        "initial capacity was already set to %s",
        this.initialCapacity);
    checkArgument(initialCapacity >= 0);

    checkMaximumSize(8, 8, Long.MAX_VALUE);

    // vary initial capacity wrt maximumSize

    for (int capacity = 0; capacity < 8; capacity++) {
      checkMaximumSize(1, capacity, 4);
      checkMaximumSize(2, capacity, 4);
      checkMaximumSize(4, capacity, 4);
      checkMaximumSize(8, capacity, 4);
    }
  }