* Client and server exchange these certificates during the handshake phase of a TLS connection.
 *
 * ### Server Authentication
 *
 * This is the most common form of TLS authentication: clients verify that servers are trusted and
 * that they own the hostnames that they represent. Server authentication is required.
 *
 * To perform server authentication:
 *

 * ```
 */
@ExperimentalOkHttpApi
class MockWebServerRule : ExternalResource() {
  val server: MockWebServer = MockWebServer()

  override fun before() {
    try {
      server.start()
    } catch (e: IOException) {
      throw RuntimeException(e)
    }
  }

  override fun after() {
    try {
      server.shutdown()
    } catch (e: IOException) {

  @Test
  fun multipleDnsLookupsForSingleCall() {
    server.enqueue(
      MockResponse.Builder()
        .code(301)
        .setHeader("Location", "http://www.fakeurl:" + server.port)
        .build(),
    )
    server.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server.hostName)
    client =
      client.newBuilder()

 *
 * ## Warning: Certificate Pinning is Dangerous!
 *
 * Pinning certificates limits your server team's abilities to update their TLS certificates. By
 * pinning certificates, you take on additional operational complexity and limit your ability to
 * migrate between certificate authorities. Do not use certificate pinning without the blessing of
 * your server's TLS administrator!
 *
 * ### Note about self-signed certificates
 *

  @Throws(IOException::class)
  fun secondCallEventSequence() {
    enableTls()
    server!!.protocols = listOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server!!.enqueue(MockResponse())
    server!!.enqueue(MockResponse())

    client.newCall(Request(server!!.url("/")))
      .execute().close()

    client.newCall(Request(server!!.url("/")))
      .execute().close()

        .build()

    serverRule.server.useHttps(localhost.sslSocketFactory())
  }

  @Test
  @Ignore("java.net.UnknownHostException: No results for localhost, in CI.")
  fun testRequest() {
    serverRule.server.enqueue(MockResponse())

    val call = client.newCall(Request(serverRule.server.url("/")))

    call.execute().use { response ->

 * responses. Although this client honors all [HTTP/1.1 (RFC 7234)][rfc_7234] cache headers, it
 * doesn't cache partial responses.
 *
 * ## Force a Network Response
 *
 * In some situations, such as after a user clicks a 'refresh' button, it may be necessary to skip
 * the cache, and fetch data directly from the server. To force a full refresh, add the `no-cache`

    // yet absolute. This is needed because server certificates do not normally contain absolute
    // names or patterns, but they should be treated as absolute. At the same time, any hostname
    // presented to this method should also be treated as absolute for the purposes of matching
    // to the server certificate.
    //   www.android.com  matches www.android.com

OkHttp Server-Sent Events
=========================

Experimental support for server-sent events.
API is not considered stable and may change at any time.

### Download

```kotlin
testImplementation("com.squareup.okhttp3:okhttp-sse:4.12.0")

  private lateinit var server: MockWebServer

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

  @Test
  fun legalToExecuteTwiceCloning() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))

    val request = Request(server.url("/"))

    val call = client.newCall(request)