TestCloseable c3 = closer.register(TestCloseable.normal());

    assertFalse(c1.isClosed());
    assertFalse(c2.isClosed());
    assertFalse(c3.isClosed());

    closer.close();

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertTrue(c3.isClosed());

    assertTrue(suppressor.suppressions.isEmpty());
  }

    assertThat(c1.socket().isClosed).isFalse()
    assertThat(c2.socket().isClosed).isFalse()

    // Add a third connection
    val c3 = factory.newConnection(pool, routeC1, 75L)

    // The third connection bounces the first.
    assertThat(pool.closeConnections(100L)).isEqualTo(0L)
    assertThat(pool.connectionCount()).isEqualTo(2)
    assertThat(c1.socket().isClosed).isTrue()

    val source2 = relay.newSource()
    source1!!.close()
    source1.close() // Unnecessary. Shouldn't decrement the reference count.
    assertThat(relay.isClosed).isFalse()
    source2!!.close()
    assertThat(relay.isClosed).isTrue()
    assertFile(Relay.PREFIX_DIRTY, -1L, -1, null, null)
  }

  @Test
  fun racingReaders() {
    val pipe = Pipe(1024)
    val sink = pipe.sink.buffer()

    TestCloseable c3 = closer.register(TestCloseable.normal());

    assertFalse(c1.isClosed());
    assertFalse(c2.isClosed());
    assertFalse(c3.isClosed());

    closer.close();

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertTrue(c3.isClosed());

    assertTrue(suppressor.suppressions.isEmpty());
  }

  }

  override fun isBound(): Boolean {
    return delegate!!.isBound
  }

  override fun isConnected(): Boolean {
    return delegate!!.isConnected
  }

  override fun isClosed(): Boolean {
    return delegate!!.isClosed
  }

  @Throws(IOException::class)
  override fun bind(localAddr: SocketAddress) {
    delegate!!.bind(localAddr)
  }

  @Throws(IOException::class)

  internal var writeSuccessCount = 0
  internal var writeAbortCount = 0
  private var networkCount = 0
  private var hitCount = 0
  private var requestCount = 0

  val isClosed: Boolean
    get() = cache.isClosed()

  internal fun get(request: Request): Response? {
    val key = key(request.url)
    val snapshot: DiskLruCache.Snapshot =
      try {
        cache[key] ?: return null

    lock.assertNotHeld()

    val nowNs = System.nanoTime()

    val rawSocket = this.rawSocket!!
    val socket = this.socket!!
    val source = this.source!!
    if (rawSocket.isClosed || socket.isClosed || socket.isInputShutdown ||
      socket.isOutputShutdown
    ) {
      return false
    }

    val http2Connection = this.http2Connection
    if (http2Connection != null) {

   * trailers. Undefined until the end of the response body.
   */
  private var trailers: Headers? = null

  /** Returns true if this connection is closed. */
  val isClosed: Boolean
    get() = state == STATE_CLOSED

  override fun createRequestBody(
    request: Request,
    contentLength: Long,
  ): Sink {
    return when {

   * resources are released and all following calls to [.newSource] return null. Guarded by this.
   */
  var sourceCount = 0

  val isClosed: Boolean
    get() = file == null

  @Throws(IOException::class)
  private fun writeHeader(
    prefix: ByteString,
    upstreamSize: Long,
    metadataSize: Long,
  ) {
    val header =

 *     Reference<?> reference = new FinalizablePhantomReference<MyServer>(myServer, frq) {
 *       public void finalizeReferent() {
 *         references.remove(this):
 *         if (!serverSocket.isClosed()) {
 *           ...log a message about how nobody called close()...
 *           try {
 *             serverSocket.close();
 *           } catch (IOException e) {
 *             ...
 *           }
 *         }