return null
    }

    val entry = Entry(response)
    var editor: DiskLruCache.Editor? = null
    try {
      editor = cache.edit(key(response.request.url)) ?: return null
      entry.writeTo(editor)
      return RealCacheRequest(editor)
    } catch (_: IOException) {
      abortQuietly(editor)
      return null
    }
  }

  @Throws(IOException::class)

    override fun contentType() = delegate.contentType()

    override fun isDuplex() = true

    override fun writeTo(sink: BufferedSink) {
      executorService.schedule({
        try {
          delegate.writeTo(sink)
          sink.close()
        } catch (e: IOException) {
          throw RuntimeException(e)
        }
      }, delayMillis, TimeUnit.MILLISECONDS)

	br := NewReader(strings.NewReader("example"))
	br.WriteTo(io.Discard)
	if err := br.UnreadRune(); err == nil {
		t.Error("UnreadRune didn't fail after WriteTo")
	}
}

func TestNoUnreadByteAfterWriteTo(t *testing.T) {
	br := NewReader(strings.NewReader("example"))
	br.WriteTo(io.Discard)
	if err := br.UnreadByte(); err == nil {
		t.Error("UnreadByte didn't fail after WriteTo")
	}
}

    assertThat(request.body?.contentLength()).isEqualTo(-1L)
    assertThat(request.body?.contentType()).isEqualTo(mediaType)

    val requestBodyBytes =
      Buffer()
        .apply {
          request.body?.writeTo(this)
        }

    val decompressedRequestBody =
      GzipSource(requestBodyBytes).use {
        it.buffer().readUtf8()
      }

    setLevel(Level.HEADERS)
    server.enqueue(MockResponse())
    val body: RequestBody =
      object : RequestBody() {
        override fun contentType() = PLAIN

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("Hi!")
        }
      }
    val response = client.newCall(request().post(body).build()).execute()
    response.body.close()
    applicationLogs

pkg runtime/trace, method (*FlightRecorder) Enabled() bool #63185
pkg runtime/trace, method (*FlightRecorder) Start() error #63185
pkg runtime/trace, method (*FlightRecorder) Stop() #63185
pkg runtime/trace, method (*FlightRecorder) WriteTo(io.Writer) (int64, error) #63185
pkg runtime/trace, type FlightRecorder struct #63185
pkg runtime/trace, type FlightRecorderConfig struct #63185
pkg runtime/trace, type FlightRecorderConfig struct, MaxBytes uint64 #63185

    object : RequestBody() {
      override fun contentType(): MediaType? = "text/plain".toMediaTypeOrNull()

      @Throws(IOException::class)
      override fun writeTo(sink: BufferedSink) {
        try {
          sink.writeUtf8("abc")
          sink.flush()
          Thread.sleep(sleepMillis.toLong())
          sink.writeUtf8("def")
        } catch (e: InterruptedException) {

      override fun contentLength(): Long = original!!.contentLength()

      override fun writeTo(sink: BufferedSink) {
        val uppercase = uppercase(sink)
        val bufferedSink = uppercase.buffer()
        original!!.writeTo(bufferedSink)
        bufferedSink.emit()
      }
    }

  private fun uppercase(original: BufferedSink): Sink =

          url = server.url("/"),
          body =
            object : ForwardingRequestBody(transferKind.newRequestBody("def")) {
              override fun writeTo(sink: BufferedSink) {
                sinkReference.set(sink)
                super.writeTo(sink)
              }
            },
        ),
      )
    assertThat(readAscii(response.body.byteStream(), Int.MAX_VALUE))
      .isEqualTo("abc")

                connection.connect(); // send type 3
                if (cachedOutput != null && doOutput) {
                    final OutputStream output = connection.getOutputStream();
                    cachedOutput.writeTo(output);
                    output.flush();
                }
                response = parseResponseCode();
                if (response != HTTP_UNAUTHORIZED && response != HTTP_PROXY_AUTH) {