val source1 = relay.newSource()!!.buffer()
    val source2 = relay.newSource()!!.buffer()
    assertThat(source1.readUtf8(5)).isEqualTo("abcde")
    assertThat(source2.readUtf8(5)).isEqualTo("abcde")
    assertThat(source2.readUtf8(5)).isEqualTo("fghij")
    assertThat(source1.readUtf8(5)).isEqualTo("fghij")
    assertThat(source1.exhausted()).isTrue()
    assertThat(source2.exhausted()).isTrue()
    source1.close()

      assertThat(source.readUtf8()).isEqualTo("Hello")
      assertThat(response.trailers()).isEqualTo(headersOf("t1", "v2"))
    }

    val call2 = client.newCall(Request(server.url("/")))
    call2.execute().use { response ->
      val source = response.body.source()
      assertThat(response.header("h1")).isEqualTo("v1")
      assertThat(source.readUtf8()).isEqualTo("Hello")

      val connection = url.openConnection() as HttpURLConnection

      assertThat(
        connection.inputStream
          .source()
          .buffer()
          .readUtf8(),
      ).contains("Peter the person")
    }
  }

  @Test
  fun testUrlConnectionPlaintextProxied() {
    testRequest {
      val proxy =
        Proxy(
          Proxy.Type.HTTP,

    val body = "".decodeHex().toResponseBody(mediaType)
    val source = body.source()
    assertThat(source.exhausted()).isTrue()
    assertThat(source.readUtf8()).isEqualTo("")
  }

  @Test
  fun sourceClosesUnderlyingSource() {
    var closed = false

    val body: ResponseBody =
      object : ResponseBody() {
        override fun contentType(): MediaType? = null

    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    val response = call.execute()
    Thread.sleep(500)
    assertFailsWith<IOException> {
      response.body.source().readUtf8()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun timeoutReadingResponseWithEnqueue() {

        "abc",
      ),
    )
    assertThat(partAbc.body.readUtf8()).isEqualTo("abcd\r\nefgh")

    val partIjk = parts.nextPart()!!
    assertThat(partIjk.headers).isEqualTo(
      headersOf(
        "Content-Type",
        "text/plain; charset=utf-8",
        "Content-ID",
        "ijk",
      ),
    )
    assertThat(partIjk.body.readUtf8()).isEqualTo("ijkl\r\nmnop\r\n")

    assertThat(parts.nextPart()).isNull()

    val metadataFile =
      fileSystem.allPaths.find {
        it.name.endsWith(".0")
      }

    if (metadataFile != null) {
      val contents =
        fileSystem.read(metadataFile) {
          readUtf8()
        }

      fileSystem.write(metadataFile) {
        writeUtf8(corruptor(contents))
      }
    }
  }

  private fun testCorruptingCache(corruptor: () -> Unit): Response {

    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(body.contentLength()).isEqualTo(buffer.size)
    assertThat(buffer.readUtf8()).isEqualTo(expected)

    val buffer2 = Buffer()
    body.writeTo(buffer2)
    assertThat(body.contentLength()).isEqualTo(buffer2.size)
    assertThat(buffer2.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun writeTwiceWithOneShot() {
    val expected =
      """
      |--123

        alreadyEncoded = alreadyEncoded,
        strict = strict,
        plusIsSpace = plusIsSpace,
        unicodeAllowed = unicodeAllowed,
        charset = charset,
      )
      return out.readUtf8()
    }
    i += Character.charCount(codePoint)
  }

  // Fast path: no characters in [pos..limit) required encoding.
  return substring(pos, limit)
}

internal fun Buffer.writePercentDecoded(

    if (i == -1L) return null // Unterminated quoted string.

    if (this[i] == '"'.code.toByte()) {
      result.write(this, i)
      // Consume '"'.
      readByte()
      return result.readUtf8()
    }

    if (size == i + 1L) return null // Dangling escape.
    result.write(this, i)
    // Consume '\'.
    readByte()
    result.write(this, 1L) // The escaped character.
  }
}

/**