}
      },
    )
    server.close(1001, "bye")
    clientListener.assertClosed(1001, "bye")
    clientListener.assertExhausted()
    serverListener.assertClosing(1000, "")
    serverListener.assertClosed(1000, "")
    serverListener.assertExhausted()
  }

  @Test
  fun unplannedCloseHandledWithoutFailure() {
    webServer.enqueue(
      MockResponse
        .Builder()

  @BeforeEach
  fun setUp() {
    client.initWebSocket(random)
    server.initWebSocket(random)
  }

  @AfterEach
  @Throws(Exception::class)
  fun tearDown() {
    client.listener.assertExhausted()
    server.listener.assertExhausted()
    server.source.close()
    client.source.close()
    taskFaker.runTasks()
    server.webSocket!!.tearDown()
    client.webSocket!!.tearDown()
    taskFaker.close()
  }

  @Test

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private val listener = EventSourceRecorder()
  private val client = clientTestRule.newClient()

  @AfterEach
  fun after() {
    listener.assertExhausted()
  }

  @Test
  fun processResponse() {
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          """
          |data: hey
          |
          |

      cancel = false
      eventSource.cancel()
    }
  }

  private fun nextEvent(): Any =
    events.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for event.")

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertEvent(
    id: String?,
    type: String?,
    data: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Event(id, type, data))
  }

  }

  fun assertClosed(
    code: Int,
    reason: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Closed(code, reason))
  }

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertOpen(): WebSocket {
    val event = nextEvent() as Open
    return event.webSocket
  }

  fun assertFailure(t: Throwable?) {

  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(eventListener))
      .build()

  @AfterEach
  fun after() {
    listener.assertExhausted()
  }

  @Test
  fun event() {
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          """
          |data: hey
          |
          |

      isClient = true,
      source = data,
      frameCallback = callback.asFrameCallback(),
      perMessageDeflate = true,
      noContextTakeover = false,
    )

  @AfterEach fun tearDown() {
    callback.assertExhausted()
  }

  @Test fun controlFramesMustBeFinal() {
    data.write("0a00".decodeHex()) // Empty pong.
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->