"network interceptor $interceptor must call proceed() exactly once",
      )
    }
  }

  @Test
  fun networkInterceptorsCannotCallProceedMultipleTimes() {
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        chain.proceed(chain.request())
        chain.proceed(chain.request())
      }
    client =

      return delegate.dispatch(request.unwrap()).wrap()
    }

    override fun peek(): mockwebserver3.MockResponse {
      return delegate.peek().wrap()
    }

    override fun shutdown() {
      delegate.shutdown()
    }
  }
}

internal fun MockResponse.wrap(): mockwebserver3.MockResponse {
  val result = mockwebserver3.MockResponse.Builder()

 */
package okhttp3.recipes;

import java.net.InetAddress;
import okhttp3.Call;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.tls.HandshakeCertificates;
import okhttp3.tls.HeldCertificate;

/**
 * Create an HTTPS server with a self-signed certificate that OkHttp trusts.
 */

    }
  }

  @Test
  fun none() {
    server.enqueue(MockResponse())
    client.newCall(request().build()).execute()
    applicationLogs.assertNoMoreLogs()
    networkLogs.assertNoMoreLogs()
  }

  @Test
  fun basicGet() {
    setLevel(Level.BASIC)
    server.enqueue(MockResponse())
    client.newCall(request().build()).execute()
    applicationLogs

    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "Last-Modified",
            formatDate(-1, TimeUnit.HOURS)!!,
            "Expires",
            formatDate(1, TimeUnit.HOURS)!!,
          ),
        body = "ABC.1",
      ),
    )
    server.enqueue(
      MockResponse(
        headers =
          headersOf(

 */
package okhttp3.logging

import assertk.assertThat
import assertk.assertions.isNotNull
import java.io.IOException
import java.net.UnknownHostException
import java.util.Arrays
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketPolicy.FailHandshake
import okhttp3.HttpUrl
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.OkHttpClientTestRule

  }

  @Test @Disabled
  fun mockResponse() {
    val mockResponse = MockResponse()
    var status: String = mockResponse.getStatus()
    var headers: Headers = mockResponse.getHeaders()
    var trailers: Headers = mockResponse.getTrailers()
    var socketPolicy: SocketPolicy = mockResponse.getSocketPolicy()
    var http2ErrorCode: Int = mockResponse.getHttp2ErrorCode()
  }

  @Test @Disabled

    setUp(mode)
    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse.Builder()
        .body(
          Buffer()
            .write(ByteArray(responseBodySize)),
        )
        .throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
        .build(),
    )
    server.enqueue(MockResponse(body = "."))

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

import okhttp3.DelegatingSocketFactory
import okhttp3.OkHttpClient
import okhttp3.OkHttpClientTestRule
import okhttp3.Request
import okhttp3.RequestBody
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
import okhttp3.testing.PlatformRule
import okio.Buffer
import okio.BufferedSink
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach

import javax.net.ssl.SSLHandshakeException
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.TrustManager
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketPolicy.DisconnectAtEnd
import okhttp3.CertificatePinner
import okhttp3.CertificatePinner.Companion.pin
import okhttp3.OkHttpClientTestRule