}
            return message;
        }
    }

    private void reconnect() throws IOException {
        final int readTimeout = getReadTimeout();
        final int connectTimeout = getConnectTimeout();

        HostnameVerifier hv = null;
        SSLSocketFactory ssf = null;
        if (this.connection instanceof HttpsURLConnection) {

  private val serverListener = WebSocketRecorder("server")
  private val random = Random(0)
  private var client =
    clientTestRule
      .newClientBuilder()
      .writeTimeout(Duration.ofMillis(500))
      .readTimeout(Duration.ofMillis(500))
      .addInterceptor(
        Interceptor { chain: Interceptor.Chain ->
          val response = chain.proceed(chain.request())
          // Ensure application interceptors never see a null body.

    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {
    check(exchange == null) { "Timeouts can't be adjusted in a network interceptor" }

    return copy(readTimeoutMillis = checkDuration("readTimeout", timeout.toLong(), unit))
  }

  override fun writeTimeoutMillis(): Int = writeTimeoutMillis

  override fun withWriteTimeout(
    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {

	return nonLoopBackIP
}

func TestNewHTTPListener(t *testing.T) {
	testCases := []struct {
		serverAddrs         []string
		tcpKeepAliveTimeout time.Duration
		readTimeout         time.Duration
		writeTimeout        time.Duration
		expectedListenErrs  []bool
	}{

                        if (httpConfigurationAll != null) {
                            requestTimeoutXml = httpConfigurationAll.getChild("readTimeout", false);
                            if (requestTimeoutXml != null) {
                                requestTimeout = Integer.parseInt(requestTimeoutXml.getValue());

 *   <li>connectTimeout - Connection timeout in milliseconds (default: 10000)</li>
 *   <li>writeTimeout - Write timeout in milliseconds (default: 10000)</li>
 *   <li>readTimeout - Read timeout in milliseconds (default: 10000)</li>
 * </ul>
 *
 * <p>The client supports URLs in the format: {@code gcs://bucket-name/object-path}
 *
 * <p>Features:
 * <ul>

    // First request: time out after 1s.
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofSeconds(1))
        .build()
    executeSynchronously("/a").assertBody("abc")

    // Second request: time out after 250ms.
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(250))
        .build()

	public final fun proxySelector (Ljava/net/ProxySelector;)Lokhttp3/OkHttpClient$Builder;
	public final fun readTimeout (JLjava/util/concurrent/TimeUnit;)Lokhttp3/OkHttpClient$Builder;
	public final fun readTimeout (Ljava/time/Duration;)Lokhttp3/OkHttpClient$Builder;
	public final fun readTimeout-LRDsOJo (J)Lokhttp3/OkHttpClient$Builder;
	public final fun retryOnConnectionFailure (Z)Lokhttp3/OkHttpClient$Builder;

    server.enqueue(
      MockResponse
        .Builder()
        .headersDelay(2, TimeUnit.SECONDS)
        .build(),
    )
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(250))
        .build()
    val call =
      client.newCallWithListener(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )

        assertThat(chain.readTimeoutMillis()).isEqualTo(100)
        chain.proceed(chain.request())
      }
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofSeconds(5))
        .addInterceptor(interceptor1)
        .addInterceptor(interceptor2)
        .build()
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")