override fun close() {
          sourceClosed = true
          super.close()
        }
      }.buffer()

    override val sink: BufferedSink =
      object : ForwardingSink(delegate.sink) {
        override fun close() {
          sinkClosed = true
          super.close()
        }
      }.buffer()

    fun initWebSocket(
      random: Random?,

  }

  @Test
  fun fragmentNonAscii() {
    val url = "http://host/#Σ".toHttpUrl()
    assertThat(url.toUri().toString()).isEqualTo("http://host/#Σ")
  }

  @Test
  fun fragmentPercentEncodedNonAscii() {
    val url = "http://host/#%C2%80".toHttpUrl()
    assertThat(url.toUri().toString()).isEqualTo("http://host/#%C2%80")
  }

  @Test
  fun fragmentPercentEncodedPartialCodePoint() {

  }

  @Test
  fun stringWithDefaultCharsetAdded() {
    val contentType = "text/plain".toMediaType()
    val body = "\u0800".toRequestBody(contentType)
    assertThat(body.contentType()).isEqualTo("text/plain; charset=utf-8".toMediaType())
    assertThat(body.contentLength()).isEqualTo(3)
    assertThat(bodyToHex(body)).isEqualTo("e0a080")
  }

  @Test
  fun stringWithNonDefaultCharsetSpecified() {

  private val setAlpnProtocols =
    sslSocketClass.getMethod("setAlpnProtocols", ByteArray::class.java)

  override fun isSupported(): Boolean = AndroidPlatform.isSupported

  override fun matchesSocket(sslSocket: SSLSocket): Boolean = sslSocketClass.isInstance(sslSocket)

  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {

        expectedBucketNumber,
        arch,
        failStage,
    )

    fun asId(projectId: String): String = "${projectId}_$testCoveragePrefix"

    fun asId(model: CIBuildModel): String = asId(model.projectId)

    private val testCoveragePrefix
        get() = "${testType.name.toCamelCase().toCapitalized()}_$uuid"

    fun asConfigurationId(
        model: CIBuildModel,
        subProject: String = "",

        .byteCount(),
    ).isEqualTo(20L)
  }

  @Test fun addDate() {
    val expected = Date(0L)
    val headers =
      Headers
        .Builder()
        .add("testDate", expected)
        .build()
    assertThat(headers["testDate"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")
    assertThat(headers.getDate("testDate")).isEqualTo(Date(0L))
  }

  @Test fun addInstant() {
    val expected = Instant.ofEpochMilli(0L)

@Timeout(30)
class CustomDispatcherTest {
  @StartStop private val mockWebServer = MockWebServer()

  @Test
  fun simpleDispatch() {
    val requestsMade = mutableListOf<RecordedRequest>()
    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          requestsMade.add(request)
          return MockResponse()
        }
      }

    )
  }

  @Test fun simplifyCanonicalizesType() {
    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0000, 0x002c, TYPE_DISALLOWED_STD3_VALID, ByteString.EMPTY),
        ),
      ),
    ).containsExactly(
      Mapping(0x0000, 0x002c, TYPE_VALID, ByteString.EMPTY),
    )
  }

  @Test fun simplifyCombinesCanonicalEquivalent() {
    assertThat(

   */
  fun cancel()

  /**
   * Carries an exchange. This is usually a connection, but it could also be a connect plan for
   * CONNECT tunnels. Note that CONNECT tunnels are significantly less capable than connections.
   */
  interface Carrier {
    val route: Route

    fun trackFailure(
      call: RealCall,
      e: IOException?,
    )

    fun noNewExchanges()

    fun cancel()
  }

  interface FrameCallback {
    @Throws(IOException::class)
    fun onReadMessage(text: String)

    @Throws(IOException::class)
    fun onReadMessage(bytes: ByteString)

    fun onReadPing(payload: ByteString)

    fun onReadPong(payload: ByteString)

    fun onReadClose(
      code: Int,
      reason: String,
    )
  }

  /**