@StartStop
  private val server = MockWebServer()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client: OkHttpClient = clientTestRule.newClient()

  @Test
  fun connectionsAreReused() {
    server.enqueue(MockResponse(body = "a"))
    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))

  private val server = MockWebServer()

  private val listener = RecordingConnectionListener()
  private val handshakeCertificates = localhost()

  open val fastFallback: Boolean get() = true

  private var client: OkHttpClient =
    clientTestRule
      .newClientBuilder()
      .connectionPool(ConnectionPool(connectionListener = listener))
      .fastFallback(fastFallback)
      .build()

  @BeforeEach
  fun setUp() {

  private lateinit var serverIpv4: MockWebServer
  private lateinit var serverIpv6: MockWebServer

  private val eventRecorder = EventRecorder()
  private lateinit var client: OkHttpClient
  private lateinit var url: HttpUrl

  /**
   * This is mutable and order matters. By default, it contains [IPv4, IPv6]. Tests may manipulate
   * it to prefer IPv6.
   */

import java.security.cert.CertificateFactory
import java.security.cert.X509Certificate
import javax.net.ssl.SSLSession
import javax.security.auth.x500.X500Principal
import okhttp3.FakeSSLSession
import okhttp3.OkHttpClient
import okhttp3.internal.canParseAsIpAddress
import okhttp3.internal.platform.Platform.Companion.isAndroid
import okhttp3.testing.PlatformRule
import okhttp3.tls.HeldCertificate
import org.junit.jupiter.api.Test

  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private lateinit var client: OkHttpClient
  private lateinit var rootCa: HeldCertificate
  private lateinit var certificate: HeldCertificate
  private val dns = FakeDns()
  private lateinit var url: HttpUrl
  private lateinit var serverIps: List<InetAddress>

    server.enqueue(MockResponse(body = "ghi"))
    client =
      OkHttpClient
        .Builder()
        .connectionPool(client.connectionPool)
        .proxy(server.proxyAddress)
        .build()
    executeSynchronously("/a").assertBody("abc")
    client =
      OkHttpClient
        .Builder()
        .connectionPool(client.connectionPool)
        .proxy(server.proxyAddress)

    assertThat(response.body.string()).isEqualTo("abc")
    response.body.close()
    assertThat(eventRecorder.recordedEventTypes()).isEmpty()
  }

  /** Listeners added with [OkHttpClient.Builder.eventListener] are also added to clones. */
  @Test
  fun clonedCallHasClientEventListeners() {
    assumeTrue(listenerInstalledOn == ListenerInstalledOn.Client)

    server.enqueue(

 * bandwidth.
 *
 * The Cache instance must have exclusive access to the [directory], since the internal data structures
 * may cause corruption or runtime errors if not. It may however be shared amongst multiple OkHttpClient
 * instances.
 *
 * ## Cache Optimization
 *
 * To measure cache effectiveness, this class tracks three statistics:
 *

import okhttp3.Headers.Companion.headersOf
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.Interceptor
import okhttp3.MediaType
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.OkHttpClientTestRule
import okhttp3.Protocol
import okhttp3.RecordingCookieJar
import okhttp3.RecordingHostnameVerifier
import okhttp3.Request
import okhttp3.RequestBody
import okhttp3.Response

  private val server = MockWebServer()

  @StartStop
  private val server2 = MockWebServer()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private lateinit var client: OkHttpClient
  private lateinit var cache: Cache
  private val cookieManager = CookieManager()

  @BeforeEach
  fun setUp() {
    platform.assumeNotOpenJSSE()
    server.protocolNegotiationEnabled = false