connectionListener = ConnectionListener.NONE,
  )

  constructor() : this(5, 5, TimeUnit.MINUTES)

  /** Returns the number of idle connections in the pool. */
  fun idleConnectionCount(): Int = delegate.idleConnectionCount()

  /** Returns total number of connections in the pool. */
  fun connectionCount(): Int = delegate.connectionCount()

  internal val connectionListener: ConnectionListener

      }
  }

  @Test
  fun connectionPool() {
    var connectionPool = ConnectionPool()
    connectionPool = ConnectionPool(0, 0L, TimeUnit.SECONDS)
    val idleConnectionCount: Int = connectionPool.idleConnectionCount()
    val connectionCount: Int = connectionPool.connectionCount()
    connectionPool.evictAll()
  }

  @Test
  fun connectionSpec() {

  init {
    // Put a floor on the keep alive duration, otherwise cleanup will spin loop.
    require(keepAliveDuration > 0L) { "keepAliveDuration <= 0: $keepAliveDuration" }
  }

  fun idleConnectionCount(): Int {
    return connections.count {
      it.withLock { it.calls.isEmpty() }
    }
  }

  fun connectionCount(): Int {
    return connections.size
  }

  /**

        .build()
    val request = Request(server.url("/"))
    executeSynchronously(request)
      .assertFailure(IOException::class.java)
    assertThat(client.connectionPool.idleConnectionCount()).isEqualTo(1)
  }

  @Test
  fun failedProxyAuthenticatorReleasesConnection() {
    server.enqueue(
      MockResponse(code = 407),
    )
    client =
      client.newBuilder()

	public final fun connectionCount ()I
	public final fun evictAll ()V
	public final fun idleConnectionCount ()I
	public final fun setPolicy (Lokhttp3/Address;Lokhttp3/ConnectionPool$AddressPolicy;)V
}

public final class okhttp3/ConnectionPool$AddressPolicy {
	public final field backoffDelayMillis J

        .build(),
    )
    assertThat(get(server.url("/")).body.string()).isEqualTo("A")
    assertThat(get(server.url("/")).body.string()).isEqualTo("A")
    assertThat(client.connectionPool.idleConnectionCount()).isEqualTo(1)
  }

  @Test
  fun expiresDateBeforeModifiedDate() {
    assertConditionallyCached(
      MockResponse.Builder()

        .socketPolicy(DisconnectAtEnd)
        .build(),
    )
    val response = getResponse(newRequest("/"))
    assertContent("{}", response)
    assertThat(client.connectionPool.idleConnectionCount()).isEqualTo(0)
  }

  @Test
  fun earlyDisconnectDoesntHarmPoolingWithChunkedEncoding() {
    testEarlyDisconnectDoesntHarmPooling(TransferKind.CHUNKED)
  }

  @Test