} else {
          var buffer = Buffer()
          requestBody.writeTo(buffer)

          var gzippedLength: Long? = null
          if ("gzip".equals(headers["Content-Encoding"], ignoreCase = true)) {
            gzippedLength = buffer.size
            GzipSource(buffer).use { gzippedResponseBody ->
              buffer = Buffer()
              buffer.writeAll(gzippedResponseBody)
            }

import okhttp3.internal.closeQuietly
import okio.Buffer
import okio.BufferedSource
import okio.ByteString
import okio.buffer
import okio.source

/** Replays prerecorded outgoing frames and records incoming frames.  */
class MockHttp2Peer : Closeable {
  private var frameCount = 0
  private var client = false
  private val bytesOut = Buffer()
  private var writer = Http2Writer(bytesOut, client)

    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {
    if (!string.regionMatches(pos, PREFIX_STRING, 0, 4, ignoreCase = true)) {
      result.writeUtf8(string, pos, limit)
      return true
    }

    var pos = pos + 4 // 'xn--'.size.

    // We'd prefer to operate directly on `result` but it doesn't offer insertCodePoint(), only

import okio.BufferedSink
import okio.ByteString
import okio.ByteString.Companion.encodeUtf8
import okio.FileSystem
import okio.Path
import okio.Path.Companion.toPath
import okio.buffer
import okio.gzip

/**
 * Downloads the public suffix list from https://publicsuffix.org/list/public_suffix_list.dat and
 * transforms the file into an efficient format used by OkHttp.
 *
 *

  private fun sourceReader(source: Source?): Callable<ByteString> {
    return Callable {
      val buffer = Buffer()
      while (source!!.read(buffer, 16384) != -1L) {
      }
      source.close()
      buffer.readByteString()
    }
  }

  private fun assertFile(
    prefix: ByteString,
    upstreamSize: Long,
    metadataSize: Int,

import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.containers.BasicMockServerTest.Companion.MOCKSERVER_IMAGE
import okhttp3.containers.BasicMockServerTest.Companion.trustMockServer
import okio.buffer
import okio.source
import org.junit.jupiter.api.Test
import org.mockserver.client.MockServerClient
import org.mockserver.configuration.Configuration
import org.mockserver.logging.MockServerLogger

  )

  private fun execute(
    engine: HttpEngine,
    executor: ExecutorService,
    url: String,
  ): CompletableFuture<Response> {
    val completableFuture = CompletableFuture<Response>()
    val buffer = Buffer()

    val req =
      engine.newUrlRequestBuilder(
        url,
        executor,
        object : Callback {
          override fun onRedirectReceived(
            request: UrlRequest,

        // that happens, then we will have buffered bytes that are needed by the SSLSocket!
        // This check is imperfect: it doesn't tell us whether a handshake will succeed, just
        // that it will almost certainly fail because the proxy has sent unexpected data.
        if (source?.buffer?.exhausted() == false || sink?.buffer?.exhausted() == false) {
          throw IOException("TLS tunnel buffered too many bytes!")
        }

  @Test
  fun responseBodyIsBinary() {
    setLevel(Level.BODY)
    val buffer = Buffer()
    buffer.writeUtf8CodePoint(0x89)
    buffer.writeUtf8CodePoint(0x50)
    buffer.writeUtf8CodePoint(0x4e)
    buffer.writeUtf8CodePoint(0x47)
    buffer.writeUtf8CodePoint(0x0d)
    buffer.writeUtf8CodePoint(0x0a)
    buffer.writeUtf8CodePoint(0x1a)
    buffer.writeUtf8CodePoint(0x0a)
    server.enqueue(
      MockResponse.Builder()

import okhttp3.internal.http.HttpMethod
import okhttp3.internal.http.StatusLine
import okhttp3.internal.platform.Platform
import okhttp3.internal.platform.Platform.Companion.WARN
import okhttp3.internal.toLongOrDefault
import okio.Buffer
import okio.BufferedSink
import okio.BufferedSource
import okio.ByteString.Companion.decodeBase64
import okio.ByteString.Companion.encodeUtf8
import okio.ByteString.Companion.toByteString
import okio.FileSystem