.post(
            object : RequestBody() {
              override fun contentType() = null

              override fun writeTo(sink: BufferedSink) {
                for (i in 0..9) {
                  sink.writeByte(0)
                  sink.flush()
                  sleep(100)
                }
                fail("Expected connection to be closed")
              }
            },

import okhttp3.MediaType
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.curl.Main
import okhttp3.internal.http.StatusLine
import okio.sink

internal fun Main.commonCreateRequest(): Request {
  val request = Request.Builder()

  val requestMethod = method ?: if (data != null) "POST" else "GET"

  val url = url ?: throw IOException("No url provided")

        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          check(!closed)
          return data.read(sink, byteCount)
        }

        override fun timeout(): Timeout = Timeout.NONE
      }
    return source.buffer().asResponseBody(null, -1)
  }

  /**
   * Sends a stream of data from the {@code from} object into the sink {@code into}. There is no
   * requirement that this data be complete enough to fully reconstitute the object later.
   *
   * @since 12.0 (in Guava 11.0, {@code PrimitiveSink} was named {@code Sink})
   */
  void funnel(@ParametricNullness T from, PrimitiveSink into);

    }

    private Source source(Source source) {
      return new ForwardingSource(source) {
        long totalBytesRead = 0L;

        @Override public long read(Buffer sink, long byteCount) throws IOException {
          long bytesRead = super.read(sink, byteCount);
          // read() returns the number of bytes read, or -1 if this source is exhausted.
          totalBytesRead += bytesRead != -1 ? bytesRead : 0;

 * limitations under the License.
 */
package okhttp3.internal.cache

import java.io.IOException
import okio.Sink

interface CacheRequest {
  @Throws(IOException::class)
  fun body(): Sink

  fun abort()

    @Throws(IOException::class)
    override fun contentLength(): Long = delegate.contentLength()

    @Throws(IOException::class)
    override fun writeTo(sink: BufferedSink) {
      val forwardingSink =
        object : ForwardingSink(sink) {
          private var totalBytesWritten: Long = 0
          private var completed = false

          override fun write(
            source: Buffer,

     */
    fun newSink(index: Int): Sink {
      synchronized(this@DiskLruCache) {
        check(!done)
        if (entry.currentEditor != this) {
          return blackholeSink()
        }
        if (!entry.readable) {
          written!![index] = true
        }
        val dirtyFile = entry.dirtyFiles[index]
        val sink: Sink
        try {
          sink = fileSystem.sink(dirtyFile)

        .method("POST", AsyncRequestBody())
        .build()
    val call = client.newCall(request)
    call.execute().use { response ->
      val sink = (request.body as AsyncRequestBody?)!!.takeSink()
      sink.writeUtf8("hey\n")
      sink.writeUtf8("whats going on\n")
      sink.close()
    }
    body.awaitSuccess()
  }

  @Test
  fun requestBodyEndsAfterResponseBody() {
    enableProtocol(Protocol.HTTP_2)

    }
  }

  /**
   * Copies the contents of this source to the given sink.
   *
   * @return the number of characters copied
   * @throws IOException if an I/O error occurs while reading from this source or writing to {@code
   *     sink}
   */
  @CanIgnoreReturnValue
  public long copyTo(CharSink sink) throws IOException {
    checkNotNull(sink);

    Closer closer = Closer.create();
    try {