verify(mockResponse).flushBuffer();
    }

    /**
     * Test case for when the 'Authorization' header contains a Type 1 NTLM message.
     * Expects the server to respond with a 'WWW-Authenticate' header containing a Type 2 message.
     * @throws IOException
     */
    @Test
    public void testAuthenticate_Type1Message() throws IOException {
        // Setup: "Authorization" header with a Type 1 message

    rather than the duration specified in the response's cache-control header.
 *  Fix: Verify certificate IP addresses in canonical form. When a server presents a TLS certificate
    containing an IP address we must match that address against the URL's IP address, even when the
    two addresses are encoded differently, such as `192.168.1.1` and `0::0:0:FFFF:C0A8:101`. Note

   */
  open fun proxySelectStart(
    call: Call,
    url: HttpUrl,
  ) {
  }

  /**
   * Invoked after proxy selection.
   *
   * Note that the list of proxies is never null, but it may be a list containing
   * only [Proxy.NO_PROXY]. This comes up in several situations:
   *
   * * If neither a proxy nor proxy selector is configured.
   * * If the proxy is configured explicitly as [Proxy.NO_PROXY].

  /** Returns a new, empty {@link TreeRangeMap}. */
  public static <K extends Comparable, V> TreeRangeMap<K, V> create() {
    return new TreeRangeMap<>();
  }

  /**
   * Returns a new {@link TreeRangeMap} containing the same ranges as the given {@code RangeMap}.
   *
   * @since 33.4.0
   */
  @SuppressWarnings("unchecked")
  public static <K extends Comparable<?>, V> TreeRangeMap<K, V> copyOf(

      int i = 0;
      for (Object e : elements) {
        array[i++] = (Long) e;
      }
      return create(array);
    }

    /**
     * Creates a new collection containing the given elements; implement this method instead of
     * {@link #create(Object...)}.
     */
    protected abstract List<Long> create(Long[] elements);

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

    }

    @Test
    @DisplayName("Reading with zero-length array returns 0")
    void readZeroLengthArrayReturnsZero() throws IOException {
        // Create stream with a message containing data
        byte[] data = new byte[] { 1, 2 };
        InputStream in = new ByteArrayInputStream(concat(messageHeader(2), data));
        SocketInputStream sis = new SocketInputStream(in);

 * <li>{@link #arraySettingsIndexName}: Name of the array settings index.</li>
 * <li>{@link #settingsId}: ID of the settings.</li>
 * <li>{@link #settings}: SuggestSettings instance containing configuration settings.</li>
 * <li>{@link #encoder}: Base64 encoder instance for encoding IDs.</li>
 * </ul>
 */
public class ArraySettings {

     *
     * @param queryId the unique identifier for the search query
     * @param documentItems the list of document maps containing search results
     */
    public void storeQueryId(final String queryId, final List<Map<String, Object>> documentItems) {
        LaRequestUtil.getOptionalRequest().map(req -> req.getSession(false)).ifPresent(session -> {

            this.obj = obj;
        }

        final int referent;

        @SuppressWarnings("unused")
        private final Object obj;
    }

    /**
     * The underlying byte buffer containing the NDR data.
     */
    public byte[] buf;

    /**
     * The starting position in the buffer.
     */
    public int start;

    /**
     * The current position in the buffer.
     */

Now try sending an invalid item like:

```JSON
{
  "title": "towel",
  "size": "XL"
}
```

You will receive a response telling you that the data is invalid containing the received body:

```JSON hl_lines="12-15"
{
  "detail": [
    {
      "loc": [
        "body",
        "size"
      ],
      "msg": "value is not a valid integer",