this.maxSize = maxSize;
  }

  /**
   * Creates and returns a new evicting queue that will hold up to {@code maxSize} elements.
   *
   * <p>When {@code maxSize} is zero, elements will be evicted immediately after being added to the
   * queue.
   */
  public static <E> EvictingQueue<E> create(int maxSize) {
    return new EvictingQueue<>(maxSize);
  }

  /**

        // verify that subsequent call gives SMBSERVER_NAME
        String next = ua.nextCalledName();
        // Assert
        assertEquals(NbtAddress.SMBSERVER_NAME, next, "nextCalledName should return SMBSERVER_NAME after first call");
    }

    @Test
    void getAddressReturnsOriginalObject() {
        InetAddress dummy = mock(InetAddress.class);
        UniAddress ua = new UniAddress(dummy);

/// note

`data` and `raw_data` are mutually exclusive. You can only set one of them on each `ServerSentEvent`.

///

## Resuming with `Last-Event-ID` { #resuming-with-last-event-id }

When a browser reconnects after a connection drop, it sends the last received `id` in the `Last-Event-ID` header.

You can read it as a header parameter and use it to resume the stream from where the client left off:

     * @param indexingOps The indexing operations for writing items
     * @param deletionOps The deletion operations for removing items
     * @param badWordsSupplier Supplier to get current bad words array (for updating after changes)
     */
    public WordManagementOperations(final SuggestSettings settings, final Normalizer normalizer, final IndexingOperations indexingOps,

     */
    public RankFusionProcessor() {
        // Default constructor - initialization is done in init() method
    }

    /**
     * Initializes the rank fusion processor after construction.
     * Sets up the window size based on configuration and loads available searchers.
     * This method is called automatically after the bean is constructed.
     */

      }
      if (to != Bound.NO_BOUND) {
        extremeValues.add(delegate.aboveSamplesLesser());
        extremeValues.add(delegate.aboveSamplesGreater());
      }

      // the regular values should be visible after filtering
      List<@Nullable Object> allEntries = new ArrayList<>();
      allEntries.addAll(extremeValues);
      allEntries.addAll(normalValues);
      SortedSet<E> set = delegate.create(allEntries.toArray());

      super(16);
    }

    private boolean finished = false;

    /*
     * This trick allows us to avoid having separate states for "first four ints" and "all other
     * four int chunks."  The state we want after the first four bytes is
     *
     * crc0 = ~int0
     * crc1 = int1
     * crc2 = int2
     * crc3 = int3
     *
     * ...so we set crc0 so that computeForWord(crc0) = -1 and xoring it with the first int

    operation ->> dep_func: Return from path operation
    Note over dep_func: Run code after yield
    Note over dep_func: ✅ Dependency closed
    dep_func ->> client: Send response to client
    Note over client: Response sent
    Note over dep_req: Run code after yield
    Note over dep_req: ✅ Dependency closed
```

        .url("/a")
        .toUrl()
        .openConnection()
        .getInputStream()
    assertThat(inputStream!!.read()).isEqualTo('B'.code)
  }

  /**
   * Throttle the request body by sleeping 500ms after every 3 bytes. With a 6-byte request, this
   * should yield one sleep for a total delay of 500ms.
   */
  @Test
  fun throttleRequest() {
    assumeNotWindows()
    server.enqueue(
      MockResponse

                    transitionTo(State.OPEN);
                    throw new CircuitOpenException("Circuit breaker '" + name + "' reopened after max attempts");
                }
            }

            try {
                T result = operation.get();
                long responseTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);