* called by readers.
 */
@ExperimentalOkHttpApi
interface MockResponseBody {
  /** The length of this response in bytes, or -1 if unknown. */
  val contentLength: Long

  @Throws(IOException::class)
  fun writeTo(sink: BufferedSink)

 */

package com.google.common.io;

import com.google.common.collect.ImmutableSet;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * A byte sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
public class TestByteSink extends ByteSink implements TestStreamSupplier {

        override fun contentType(): MediaType? {
          return null
        }

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("abc")
          sink.flush()
          makeFailingCall()
          sink.writeUtf8("def")
          sink.flush()
        }
      }
    val call =
      client.newCall(
        Request(
          url = server.url("/"),

      private val timeout = Timeout()

      override fun close() {
        if (currentPart == this) {
          currentPart = null
        }
      }

      override fun read(
        sink: Buffer,
        byteCount: Long,
      ): Long {
        require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
        check(currentPart == this) { "closed" }

        source.timeout().intersectWith(timeout) {

import static java.nio.charset.StandardCharsets.UTF_8;

import java.io.FilterWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

/**
 * A char sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
public class TestCharSink extends CharSink implements TestStreamSupplier {

  private final TestByteSink byteSink;

          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")

    ) = error("unsupported")

    override fun take() = error("unsupported")

    override fun remainingCapacity() = error("unsupported")

    override fun drainTo(sink: MutableCollection<in T>) = error("unsupported")

    override fun drainTo(
      sink: MutableCollection<in T>,
      maxElements: Int,
    ) = error("unsupported")
  }

              override fun contentLength(): Long = postBytes.size.toLong()

              override fun writeTo(sink: BufferedSink) {
                sink.write(postBytes) // push bytes into the stream's buffer
                sink.flush() // Http2Connection.writeData subject to write window
                sink.close() // Http2Connection.writeData empty frame
              }
            },
        ),
      )

      @Override public long contentLength() {
        return -1; // We don't know the compressed length in advance!
      }

      @Override public void writeTo(BufferedSink sink) throws IOException {
        BufferedSink gzipSink = Okio.buffer(new GzipSink(sink));
        body.writeTo(gzipSink);
        gzipSink.close();
      }
    };
  }
}
```

### Rewriting Responses

    synchronized(this) {
      this.name = name
      this.streams = streams
      this.writer =
        WebSocketWriter(
          isClient = streams.client,
          sink = streams.sink,
          random = random,
          perMessageDeflate = extensions.perMessageDeflate,
          noContextTakeover = extensions.noContextTakeover(streams.client),
          minimumDeflateSize = minimumDeflateSize,