.filter { event: CallEvent? -> event is ConnectStart }
          .count()
      assertThat(connectCount).isEqualTo(1)
    }
  }

  /** Test which headers are sent unencrypted to the HTTP proxy.  */
  @Test
  fun proxyConnectOmitsApplicationHeaders() {
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(
      MockResponse(inTunnel = true),

    client.webSocket!!.finishReader()
    assertThat(client.closed).isTrue()
    client.listener.assertFailure(
      ProtocolException::class.java,
      "Server-sent frames must not be masked.",
    )
    server.listener.assertClosing(1000, "Hello")
    server.listener.assertExhausted() // Client should not have sent second close.
  }

  @Test

OkHttp Server-Sent Events
=========================

Experimental support for server-sent events.
API is not considered stable and may change at any time.

### Download

```kotlin
testImplementation("com.squareup.okhttp3:okhttp-sse:4.12.0")

      if (requestBody == null || !requestBody.isDuplex()) {
        exchange.finishRequest()
      }
    } catch (e: IOException) {
      if (e is ConnectionShutdownException) {
        throw e // No request was sent so there's no response to read.
      }
      if (!exchange.hasFailure) {
        throw e // Don't attempt to read the response; we failed to send the request.
      }
      sendRequestException = e
    }

   *
   * A push promise contains all the headers that pertain to a server-initiated request, and a
   * `promisedStreamId` to which response frames will be delivered. Push promise frames are sent as
   * a part of the response to `streamId`. The `promisedStreamId` has a priority of one greater than
   * `streamId`.
   *
   * @param streamId client-initiated stream ID.  Must be an odd number.

package okhttp3

import java.io.IOException
import okhttp3.Interceptor.Chain
import okio.Buffer
import okio.BufferedSink
import okio.ForwardingSink
import okio.Sink
import okio.buffer

/** Rewrites the request body sent to the server to be all uppercase.  */
class UppercaseRequestInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Chain): Response {
    return chain.proceed(uppercaseRequest(chain.request()))

 *  Include `Content-Type` and `Content-Encoding` in the Apache HTTP client
    adapter. (thanks kwuollett)
 *  Add a media type class to OkHttp.
 *  Change custom header prefix:

    ```
    X-Android-Sent-Millis is now OkHttp-Sent-Millis
    X-Android-Received-Millis is now OkHttp-Received-Millis
    X-Android-Response-Source is now OkHttp-Response-Source
    X-Android-Selected-Transport is now OkHttp-Selected-Transport
    ```

      assertThat(expected.message)
        .isEqualTo("Client-sent frames must be masked.")
    }
  }

  @Test fun serverSentFramesMustNotBeMasked() {
    data.write("8180".decodeHex())
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Server-sent frames must not be masked.")
    }
  }

      assertThat(queueSize).isBetween(0L, messageCount * message.size)
      // Expect to fail before enqueueing 32 MiB.
      assertThat(messageCount).isLessThan(32L)
    }

    // Confirm all sent messages were received, followed by a client-initiated close.
    val server = serverListener.assertOpen()
    for (i in 0 until messageCount) {
      serverListener.assertBinaryMessage(message)
    }

     */
    fun goAway(
      lastGoodStreamId: Int,
      errorCode: ErrorCode,
      debugData: ByteString,
    )

    /**
     * Notifies that an additional `windowSizeIncrement` bytes can be sent on `streamId`, or the
     * connection if `streamId` is zero.
     */
    fun windowUpdate(
      streamId: Int,
      windowSizeIncrement: Long,
    )

    /**