HeldCertificate.Builder()
        .certificateAuthority(1)
        .build()
    val clientIntermediate =
      HeldCertificate.Builder()
        .certificateAuthority(0)
        .signedBy(clientRoot)
        .build()
    val clientCertificate =
      HeldCertificate.Builder()
        .signedBy(clientIntermediate)
        .build()
    val serverRoot =
      HeldCertificate.Builder()
        .certificateAuthority(1)

        .build()
    server.enqueue(
      MockResponse.Builder()
        .addHeader("SeNsItIvE", "Value").addHeader("Not-Sensitive", "Value")
        .build(),
    )
    val response =
      client
        .newCall(
          request()
            .addHeader("SeNsItIvE", "Value")
            .addHeader("Not-Sensitive", "Value")
            .build(),
        )
        .execute()

  private lateinit var dns: Dns
  private val cacheFs = FakeFileSystem()
  private val bootstrapClient =
    OkHttpClient.Builder()
      .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
      .build()

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    server.protocols = bootstrapClient.protocols
    dns = buildLocalhost(bootstrapClient, false)
  }

  @Test
  fun getOne() {

          .build(),
      )
      .setDnsOptions(
        DnsOptions.Builder()
          .setUseHttpStackDnsResolver(DnsOptions.DNS_OPTION_ENABLED)
          .setStaleDns(DnsOptions.DNS_OPTION_ENABLED)
          .setPersistHostCache(DnsOptions.DNS_OPTION_ENABLED)
          .build(),
      )
      .setQuicOptions(
        QuicOptions.Builder()

 * directive:
 *
 * ```java
 * Request request = new Request.Builder()
 *     .cacheControl(new CacheControl.Builder().noCache().build())
 *     .url("http://publicobject.com/helloworld.txt")
 *     .build();
 * ```
 *
 * If it is only necessary to force a cached response to be validated by the server, use the more
 * efficient `max-age=0` directive instead:
 *
 * ```java

      val client =
        OkHttpClient.Builder()
          .proxy(Proxy(Proxy.Type.HTTP, it.remoteAddress()))
          .build()

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

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

      OkHttpClient.Builder()
        .cache(Cache(FakeFileSystem(), "/cache".toPath(), 10_000_000))
        .build()
  }

  @Test
  fun testRequestExternal() {
    assumeNetwork()

    val request = Request("https://www.google.com/robots.txt".toHttpUrl())

    val networkRequest =
      request.newBuilder()
        .build()

    val call = client.newCall(networkRequest)

    call.execute().use { response ->

    else -> toInt()
  }
}

internal fun CacheControl.Companion.commonForceNetwork() =
  CacheControl.Builder()
    .noCache()
    .build()

internal fun CacheControl.Companion.commonForceCache() =
  CacheControl.Builder()
    .onlyIfCached()
    .maxStale(Int.MAX_VALUE.seconds)
    .build()

internal fun CacheControl.Builder.commonBuild(): CacheControl {
  return CacheControl(
    noCache = noCache,
    noStore = noStore,

Jesse Wilson <******@****.***> 1713403962 -0400

    } finally {
      user.removePlanToCancel(this)
      if (!success) {
        socket?.closeQuietly()
        rawSocket?.closeQuietly()
      }
    }
  }

  /** Does all the work necessary to build a full HTTP or HTTPS connection on a raw socket. */
  @Throws(IOException::class)
  private fun connectSocket() {
    val rawSocket =
      when (route.proxy.type()) {