responseBodyComplete()
      }
      return read
    }

    override fun close() {
      if (closed) return

      if (bytesRemaining != 0L &&
        !discard(ExchangeCodec.DISCARD_STREAM_TIMEOUT_MILLIS, MILLISECONDS)
      ) {
        carrier.noNewExchanges() // Unread bytes remain on the stream.
        responseBodyComplete()
      }

      closed = true
    }
  }

    val cookie = cookies[0]
    assertThat(cookie.name).isEqualTo("a")
    assertThat(cookie.value).isEqualTo("android")
    assertThat(cookie.comment).isNull()
    assertThat(cookie.commentURL).isNull()
    assertThat(cookie.discard).isFalse()
    assertThat(cookie.maxAge).isGreaterThan(100000000000L)
    assertThat(cookie.path).isEqualTo("/path")
    assertThat(cookie.secure).isTrue()
    assertThat(cookie.version).isEqualTo(0)
  }

  @Test

        }

        override fun timeout(): Timeout = source.timeout()

        @Throws(IOException::class)
        override fun close() {
          if (!cacheRequestClosed &&
            !discard(ExchangeCodec.DISCARD_STREAM_TIMEOUT_MILLIS, MILLISECONDS)
          ) {
            cacheRequestClosed = true
            cacheRequest.abort()
          }
          source.close()
        }
      }

 * source is helpful, such as when doing so completes a cache body or frees a socket connection for
 * reuse.
 */
internal fun Source.discard(
  timeout: Int,
  timeUnit: TimeUnit,
): Boolean =
  try {
    this.skipAll(timeout, timeUnit)
  } catch (_: IOException) {
    false
  }

internal fun Socket.peerName(): String {

      TYPE_GOAWAY -> readGoAway(handler, length, flags, streamId)
      TYPE_WINDOW_UPDATE -> readWindowUpdate(handler, length, flags, streamId)
      else -> source.skip(length.toLong()) // Implementations MUST discard frames of unknown types.
    }

    return true
  }

  @Throws(IOException::class)
  private fun readHeaders(
    handler: Handler,
    length: Int,
    flags: Int,
    streamId: Int,

        }

        // If the peer sends more data than we can handle, discard it and close the connection.
        if (flowControlError) {
          source.skip(remainingByteCount)
          closeLater(ErrorCode.FLOW_CONTROL_ERROR)
          return
        }

        // Discard data received after the stream is finished. It's probably a benign race.
        if (finished) {

    val request = Request(server.url("/"))
    val response1 = client.newCall(request).execute()
    val response2 = client.newCall(request).execute()
    response1.body.string() // Discard the response body.
    response2.body.string() // Discard the response body.
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
  }

  @Test