* String hostname = "publicobject.com";
 * CertificatePinner certificatePinner = new CertificatePinner.Builder()
 *     .add(hostname, "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
 *     .build();
 * OkHttpClient client = OkHttpClient.Builder()
 *     .certificatePinner(certificatePinner)
 *     .build();
 *
 * Request request = new Request.Builder()
 *     .url("https://" + hostname)
 *     .build();

  private var server: MockWebServer? = null
  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(server: MockWebServer?) {

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

  private val listener = RecordingEventListener()
  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

      request = call.request(),
      connectTimeoutMillis = 10_000,
      readTimeoutMillis = 10_000,
      writeTimeoutMillis = 10_000,
    )
  }

  fun newRoutePlanner(
    client: OkHttpClient,
    address: Address = newAddress(),
  ): RealRoutePlanner {
    val call = RealCall(client, Request(address.url), forWebSocket = false)
    val chain = newChain(call)
    return RealRoutePlanner(

  @Test
  fun setProtocolsWithoutHttp11() {
    assertFailsWith<IllegalArgumentException> {
      OkHttpClient.Builder()
        .protocols(Arrays.asList(Protocol.HTTP_2))
    }
  }

  @Test
  fun setProtocolsWithNull() {
    assertFailsWith<IllegalArgumentException> {
      OkHttpClient.Builder()
        .protocols(Arrays.asList(Protocol.HTTP_1_1, null))
    }
  }

  @Test

import mockwebserver3.RecordedRequest
import mockwebserver3.SocketPolicy
import mockwebserver3.SocketPolicy.KeepOpen
import mockwebserver3.SocketPolicy.NoResponse
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.OkHttpClientTestRule
import okhttp3.Protocol
import okhttp3.RecordingEventListener
import okhttp3.RecordingHostnameVerifier
import okhttp3.Request
import okhttp3.Response

  val clientTestRule: OkHttpClientTestRule = OkHttpClientTestRule()

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

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
  }

  @Test
  fun connectionsAreReused() {
    server.enqueue(MockResponse(body = "a"))

import mockwebserver3.SocketPolicy.DisconnectDuringResponseBody
import mockwebserver3.SocketPolicy.ShutdownServerAfterResponse
import okhttp3.Headers
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.RecordingHostnameVerifier
import okhttp3.Request
import okhttp3.TestUtil.assumeNotWindows
import okhttp3.testing.PlatformRule
import okhttp3.tls.HandshakeCertificates

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