@Throws(IOException::class)
  override fun intercept(chain: Chain): Response {
    return uppercaseResponse(chain.proceed(chain.request()))
  }

  private fun uppercaseResponse(response: Response): Response {
    val uppercaseBody: ResponseBody =
      object : ForwardingResponseBody(response.body) {
        override fun source(): BufferedSource {
          return uppercaseSource(delegate().source()).buffer()

        }
      }
    }
  }

  /**
   * Returns the number of [open streams][Http2Stream.isOpen] on this connection.
   */
  fun openStreamCount(): Int = this.withLock { streams.size }

  fun getStream(id: Int): Http2Stream? = this.withLock { streams[id] }

  internal fun removeStream(streamId: Int): Http2Stream? {
    this.withLock {
      val stream = streams.remove(streamId)

  }

  @Test
  fun canonicalizeInetAddressIPv6RepresentationOfCompatibleIPV4() {
    val addressAIpv6 = decodeIpv6("::192.168.0.1")!!
    assertThat(canonicalizeInetAddress(addressAIpv6)).isEqualTo(
      ByteArray(12) +
        byteArrayOf(
          192.toByte(),
          168.toByte(),
          0,
          1,
        ),
    )
  }

  @Test

        readyQueues.removeAt(i)
      }
    }
  }

  interface Backend {
    fun nanoTime(): Long

    fun coordinatorNotify(taskRunner: TaskRunner)

    fun coordinatorWait(
      taskRunner: TaskRunner,
      nanos: Long,
    )

    fun <T> decorate(queue: BlockingQueue<T>): BlockingQueue<T>

    fun execute(
      taskRunner: TaskRunner,
      runnable: Runnable,
    )
  }

    level = DeprecationLevel.ERROR,
  )
  fun size(): Int = size

  fun encodedName(index: Int): String = encodedNames[index]

  fun name(index: Int): String = encodedName(index).percentDecode(plusIsSpace = true)

  fun encodedValue(index: Int): String = encodedValues[index]

  fun value(index: Int): String = encodedValue(index).percentDecode(plusIsSpace = true)

  override fun contentType(): MediaType = CONTENT_TYPE

        override fun writeTo(sink: BufferedSink) {
          delegate().writeTo(uppercaseSink(sink).buffer())
        }
      }
    return request.newBuilder()
      .method(request.method, uppercaseBody)
      .build()
  }

  private fun uppercaseSink(sink: Sink): Sink {
    return object : ForwardingSink(sink) {
      @Throws(IOException::class)
      override fun write(
        source: Buffer,

  }

  @Test fun testUnsupportedCharset() {
    val mediaType = parse("text/plain; charset=utf-wtf")
    assertNull(mediaType.charsetName())
  }

  @Test fun testCharsetNameIsDoubleQuotedAndSingleQuoted() {
    val mediaType = parse("text/plain;charset=\"'utf-8'\"")
    assertNull(mediaType.charsetName())
  }

  @Test fun testCharsetNameIsDoubleQuotedSingleQuote() {

  }

  private fun registerParamProvider(
    access: Feature.BeforeAnalysisAccess,
    provider: String,
  ) {
    val providerClass = access.findClassByName(provider)
    if (providerClass != null) {
      registerTest(access, providerClass)
    } else {
      println("Missing $provider")
    }
  }

  private fun registerJupiterClasses(access: Feature.BeforeAnalysisAccess) {

   * strict than the others.
   */
  fun escapeForUri(vararg codePoints: Int) =
    apply {
      uriEscapedCodePoints.append(String(*codePoints))
    }

  /**
   * Configure code points to be stripped in conversion to `java.net.URI`. That class is more
   * strict than the others.
   */
  fun stripForUri(vararg codePoints: Int) =
    apply {

import okhttp3.internal.connection.RealConnection

internal fun parseCookie(
  currentTimeMillis: Long,
  url: HttpUrl,
  setCookie: String,
): Cookie? = Cookie.parse(currentTimeMillis, url, setCookie)

internal fun cookieToString(
  cookie: Cookie,
  forObsoleteRfc2965: Boolean,
): String = cookie.toString(forObsoleteRfc2965)

internal fun addHeaderLenient(
  builder: Headers.Builder,
  line: String,