val postBytes = "FGHIJ".toByteArray()
    server.enqueue(MockResponse(body = "ABCDE"))
    val call =
      client.newCall(
        Request(
          url = server.url("/foo"),
          body =
            object : RequestBody() {
              override fun contentType(): MediaType = "text/plain; charset=utf-8".toMediaType()

              override fun writeTo(sink: BufferedSink) {
                sink.write(postBytes)

    return DnsOverHttps.Builder().client(bootstrapClient)
      .includeIPv6(includeIPv6)
      .resolvePrivateAddresses(true)
      .url(url)
      .post(post)
      .build()
  }

  companion object {
    private fun address(host: String) = InetAddress.getByName(host)
  }

    val cacheBodyUnbuffered = cacheRequest.body()

    val source = response.body.source()
    val cacheBody = cacheBodyUnbuffered.buffer()

    val cacheWritingSource =
      object : Source {
        private var cacheRequestClosed = false

        @Throws(IOException::class)
        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {

      val response = client.newCall(Request((mockServer.secureEndpoint + "/person?name=peter").toHttpUrl())).execute()

      assertThat(response.body.string()).contains("Peter the person")
    }
  }

  companion object {
    val MOCKSERVER_IMAGE: DockerImageName =
      DockerImageName
        .parse("mockserver/mockserver")
        .withTag("mockserver-5.15.0")

    fun OkHttpClient.Builder.trustMockServer(): OkHttpClient.Builder =

  /** Returns the tag attached with [type] as a key, or null if no tag is attached with that key. */
  fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags[type])

  /**
   * Returns the tag attached with `Object.class` as a key, or null if no tag is attached with
   * that key.
   *
   * Prior to OkHttp 3.11, this method never returned null if no tag was attached. Instead it

      connectionSpecIndex = connectionSpecIndex,
      isTlsFallback = isTlsFallback,
    )
  }

  fun closeQuietly() {
    socket?.closeQuietly()
  }

  companion object {
    private const val NPE_THROW_WITH_NULL = "throw with null exception"
    private const val MAX_TUNNEL_ATTEMPTS = 21
  }

            responseHeaders,
          ),
          RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE,
          webSocketCloseTimeout,
        ).apply {
          if (client) {
            call =
              object : FailingCall() {
                override fun cancel() {
                  ******@****.***()
                }
              }
          }
        }
      webSocket!!.initReaderAndWriter(name, this)

    builder = builder.noTransform()
    builder = builder.immutable()
    val cacheControl: CacheControl = builder.build()
  }

  @Test
  fun call() {
    val call: Call =
      object : Call {
        override fun request(): Request = TODO()

        override fun execute(): Response = TODO()

        override fun enqueue(responseCallback: Callback) = TODO()

        .protocol(Protocol.HTTP_1_1)
        .message("OK")
        .code(200)
        .body(
          object : ResponseBody() {
            override fun contentType() = null

            override fun contentLength() = -1L

            override fun source() =
              object : ForwardingSource(Buffer()) {
                override fun close() {
                  responseClosed = true
                }

      val minFreshSecondsLong = timeUnit.toSeconds(minFresh.toLong())
      this.minFreshSeconds = minFreshSecondsLong.commonClampToInt()
    }

    fun build(): CacheControl = commonBuild()
  }

  companion object {
    /**
     * Cache control request directives that require network validation of responses. Note that such
     * requests may be assisted by the cache via conditional GET requests.
     */
    @JvmField