Request(
      url = server.url("/"),
      headers =
        headersOf(
          "Connection",
          "upgrade",
        ),
    )

  private fun MockSocketHandler.upgradeResponse() =
    MockResponse
      .Builder()
      .code(HTTP_SWITCHING_PROTOCOLS)
      .addHeader("Connection", "upgrade")
      .socketHandler(this)
      .build()

      printEvent("connectFailed");
    }

    @Override public void connectionAcquired(Call call, Connection connection) {
      printEvent("connectionAcquired");
    }

    @Override public void connectionReleased(Call call, Connection connection) {
      printEvent("connectionReleased");
    }

    @Override public void requestHeadersStart(Call call) {
      printEvent("requestHeadersStart");
    }

    }
  }

  /**
   * This test reproduces a crash where OkHttp attempted to use a deferred connection when the call
   * already had a healthy connection. It sets up a deferred connection by stalling the IPv6
   * connect, and it sets up a same-connection retry with [ErrorCode.REFUSED_STREAM].
   *
   * https://github.com/square/okhttp/pull/7190
   */
  @Test

            } else {
                logger.warn("Invalid index config name: configName={}", configName);
            }
        });
    }

    /**
     * Creates an HTTP client for connecting to the search engine.
     *
     * @param fessConfig the Fess configuration
     * @param host       the search engine host address
     * @return the configured HTTP client
     */

  ) {
    logWithTime("connectFailed: $protocol $ioe")
  }

  override fun connectionAcquired(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionAcquired: $connection")
  }

  override fun connectionReleased(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionReleased")
  }

  override fun requestHeadersStart(call: Call) {

import okhttp3.internal.connection.ConnectionListener
import okhttp3.internal.connection.RealConnectionPool

/**
 * Manages reuse of HTTP and HTTP/2 connections for reduced network latency. HTTP requests that
 * share the same [Address] may share a [Connection]. This class implements the policy
 * of which connections to keep open for future use.
 *

 *   <li>DEFAULT_MAX_CONNECTION_PER_ROUTE_PROPERTY: Default maximum connections per route.</li>
 *   <li>MAX_TOTAL_CONNECTION_PROPERTY: Maximum total connections.</li>
 *   <li>TIME_TO_LIVE_TIME_UNIT_PROPERTY: Time to live unit for connections.</li>
 *   <li>TIME_TO_LIVE_PROPERTY: Time to live for connections.</li>
 * </ul>
 *
 */
public class HcHttpClient extends AbstractCrawlerClient {

    /**

     * Gets the send buffer size of the underlying SMB connection
     * @return the send buffer size of the underlying connection
     * @throws CIFSException if an error occurs retrieving the buffer size
     */
    int getSendBufferSize() throws CIFSException;

    /**
     * Gets the receive buffer size of the underlying SMB connection
     * @return the receive buffer size of the underlying connection

            info.reconnecting = true;
            return info;
        }
        return null;
    }
    
    public void completeReconnect(String path, boolean success) {
        HandleInfo info = handles.get(path);
        if (info != null) {
            if (success) {
                info.updateAccessTime();
                info.reconnecting = false;
            } else {

    response.body.close()
    assertThat(listener.recordedEventTypes()).containsExactly(
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "ConnectionReleased",
    )
    val event = listener.removeUpToEvent(ConnectionEvent.ConnectEnd::class.java)
    assertThat(event.connection.route().proxy).isEqualTo(proxy)
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()