chat.loadMore();
  assertEquals("hello, world!", chat.messages());

  chat.loadMore();
  chat.loadMore();
  assertEquals(""
      + "hello, world!\n"
      + "sup, bra?\n"
      + "yo dog", chat.messages());

  // Optional: confirm that your app made the HTTP requests you were expecting.
  RecordedRequest request1 = server.takeRequest();
  assertEquals("/v1/chat/messages/", request1.getPath());

 *  New: `OkHttpClient.Builder.minWebSocketMessageToCompress()` configures a threshold for
    compressing outbound web socket messages. Configure this with 0L to always compress outbound
    messages and `Long.MAX_VALUE` to never compress outbound messages. The default is 1024L which
    compresses messages of size 1 KiB and larger. (Inbound messages are compressed or not based on
    the web socket server's configuration.)

  }

  fun assertFailure(
    cls: Class<out IOException?>?,
    vararg messages: String,
  ) {
    val event = nextEvent() as Failure
    assertThat(event.response).isNull()
    assertThat(event.t.javaClass).isEqualTo(cls)
    if (messages.isNotEmpty()) {
      assertThat(messages).contains(event.t.message)
    }
  }

  fun assertFailure() {
    nextEvent() as Failure
  }

   * messages.
   */
  open fun onOpen(
    webSocket: WebSocket,
    response: Response,
  ) {
  }

  /** Invoked when a text (type `0x1`) message has been received. */
  open fun onMessage(
    webSocket: WebSocket,
    text: String,
  ) {
  }

  /** Invoked when a binary (type `0x2`) message has been received. */
  open fun onMessage(

    }

    try {
      if (pong != null) {
        writer!!.writePong(pong)
      } else if (messageOrClose is Message) {
        val message = messageOrClose as Message
        writer!!.writeMessageFrame(message.formatOpcode, message.data)
        synchronized(this) {
          queueSize -= message.data.size.toLong()
        }
      } else if (messageOrClose is Close) {
        val close = messageOrClose as Close

    // Empty server to client message.
    val message3 = ""
    server.send(message3)
    clientListener.assertTextMessage(message3)

    // Empty client to server message.
    val message4 = ""
    client.send(message4)
    serverListener.assertTextMessage(message4)

    // Server to client message that shares context with message1.
    val message5 = message1 + message1

    }

  fun assertFailure(vararg messages: String) =
    apply {
      assertThat(failure, "No failure found").isNotNull()
      assertThat(messages).contains(failure!!.message)
    }

  fun assertFailureMatches(vararg patterns: String) =
    apply {
      val message = failure!!.message!!
      assertThat(
        patterns.firstOrNull { pattern ->
          message.matches(pattern.toRegex())
        },

      }

    fun assertNoMoreLogs() {
      assertThat(logs.size, "More messages remain: ${logs.subList(index, logs.size)}")
        .isEqualTo(index)
    }

    override fun log(message: String) {
      logs.add(message)
    }
  }

  companion object {
    private val PLAIN = "text/plain; charset=utf-8".toMediaType()
  }

        .build(),
    )
    val response = getResponse(newRequest("/"))
    assertThat(response.protocol).isEqualTo(Protocol.HTTP_1_1)
  }

  /** For example, empty Protobuf RPC messages end up as a zero-length POST.  */
  @Test
  fun zeroLengthPost() {
    zeroLengthPayload("POST")
  }

  @Test
  fun zeroLengthPost_HTTP_2() {
    enableProtocol(Protocol.HTTP_2)

      val statusLine = StatusLine.parse(headersReader.readLine())

      val responseBuilder =
        Response.Builder()
          .protocol(statusLine.protocol)
          .code(statusLine.code)
          .message(statusLine.message)
          .headers(headersReader.readHeaders())
          .trailers { error("trailers not available") }

      return when {
        expectContinue && statusLine.code == HTTP_CONTINUE -> {
          null