*/
package okhttp3.internal.http

import java.io.IOException
import okhttp3.Headers
import okhttp3.Request
import okhttp3.Response
import okhttp3.Route
import okhttp3.internal.connection.RealCall
import okio.Sink
import okio.Source

/** Encodes HTTP requests and decodes HTTP responses. */
interface ExchangeCodec {
  /** The connection or CONNECT tunnel that owns this codec. */
  val carrier: Carrier

    }

    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;

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

/**
 * Abstract {@link Hasher} that handles converting primitives to bytes using a scratch {@code
 * ByteBuffer} and streams all bytes to a sink to compute the hash.
 *
 * @author Colin Decker
 */
@ElementTypesAreNonnullByDefault
abstract class AbstractByteHasher extends AbstractHasher {

    server.listener.assertClosing(1000, "Bye!")
    server.webSocket!!.finishReader()
    server.listener.assertClosed(1000, "Bye!")
  }

  @Test
  fun emptyCloseInitiatesShutdown() {
    server.sink.write("8800".decodeHex()).emit() // Close without code.
    client.processNextFrame()
    client.listener.assertClosing(1005, "")
    client.webSocket!!.finishReader()

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

/**
 * Abstract {@link Hasher} that handles converting primitives to bytes using a scratch {@code
 * ByteBuffer} and streams all bytes to a sink to compute the hash.
 *
 * @author Colin Decker
 */
@ElementTypesAreNonnullByDefault
abstract class AbstractByteHasher extends AbstractHasher {

      source: BufferedSource = socket.source().buffer(),
      sink: BufferedSink = socket.sink().buffer(),
    ) = apply {
      this.socket = socket
      this.connectionName =
        when {
          client -> "$okHttpName $peerName"
          else -> "MockWebServer $peerName"
        }
      this.source = source
      this.sink = sink
    }

    fun listener(listener: Listener) =
      apply {

        @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();
        }
      };
    }
  }

    assertThat(body.bytes()).isEqualTo(text)
  }
}

abstract class ForwardingSource(
  val delegate: Source,
) : Source {
  override fun read(
    sink: Buffer,
    byteCount: Long,
  ): Long = delegate.read(sink, byteCount)

  override fun timeout() = delegate.timeout()

  override fun close() = delegate.close()

        val requestBody = object : RequestBody() {
          override fun contentType() = MEDIA_TYPE_MARKDOWN

          override fun writeTo(sink: BufferedSink) {
            sink.writeUtf8("Numbers\n")
            sink.writeUtf8("-------\n")
            for (i in 2..997) {
              sink.writeUtf8(String.format(" * $i = ${factor(i)}\n"))
            }
          }

          private fun factor(n: Int): String {

        return "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) {
          throw InterruptedIOException()
        }
      }
    }
  }