public final fun toProxyAddress ()Ljava/net/Proxy;
	public fun toString ()Ljava/lang/String;
	public final fun url (Ljava/lang/String;)Lokhttp3/HttpUrl;
	public final fun useHttps (Ljavax/net/ssl/SSLSocketFactory;Z)V
}

public final class okhttp3/mockwebserver/MockWebServer$Companion {
}

public final class okhttp3/mockwebserver/PushPromise {

          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .protocols(protocols.toList())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols = client.protocols
  }

  private fun assertConnectionReused(vararg requests: Request?) {
    for (i in requests.indices) {

    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

  private fun Call.cancelLater(delay: Duration) {
    thread(name = "canceler") {
      sleep(delay.inWholeMilliseconds)
      cancel()
    }
  }

      .assertLogEqual("--> GET $url")
      .assertLogMatch(Regex("""<-- HTTP FAILED: java.net.UnknownHostException: reason. $url \(\d+ms\)"""))
      .assertNoMoreLogs()
  }

  @Test
  fun http2() {
    server.useHttps(handshakeCertificates.sslSocketFactory())
    url = server.url("/")
    setLevel(Level.BASIC)
    server.enqueue(MockResponse())
    val response = client.newCall(request().build()).execute()

	public final fun takeRequest (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/RecordedRequest;
	public fun toString ()Ljava/lang/String;
	public final fun url (Ljava/lang/String;)Lokhttp3/HttpUrl;
	public final fun useHttps (Ljavax/net/ssl/SSLSocketFactory;)V
}

public final class mockwebserver3/PushPromise {
	public fun <init> (Ljava/lang/String;Ljava/lang/String;Lokhttp3/Headers;Lmockwebserver3/MockResponse;)V

    assertThat(cache.writeAbortCount()).isEqualTo(0)
    assertThat(cache.requestCount()).isEqualTo(2)
    assertThat(cache.hitCount()).isEqualTo(1)
  }

  @Test
  fun secureResponseCaching() {
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))

        ).build()
    val serverHandshakeCertificates =
      HandshakeCertificates
        .Builder()
        .heldCertificate(certificate)
        .build()
    server.useHttps(serverHandshakeCertificates.sslSocketFactory())
    url = server.url("/robots.txt")
  }

  /**
   * Test connecting to the main host then an alternative, although only subject alternative names

        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

  private inner class DelayedRequestBody(
    private val delegate: RequestBody,
    delay: Long,
    timeUnit: TimeUnit,
  ) : RequestBody() {

    return clientTestRule
  }

  @BeforeEach
  fun setUp() {
    platform.assumeNotOpenJSSE()
    if (protocol === Protocol.HTTP_2) {
      platform.assumeHttp2Support()
      server.useHttps(handshakeCertificates.sslSocketFactory())
      client =
        clientTestRule
          .newClientBuilder()
          .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
          .sslSocketFactory(

    mockWebServer.bodyLimit = 0L
    mockWebServer.protocolNegotiationEnabled = false
    mockWebServer.protocols = listOf()
    val protocols: List<Protocol> = mockWebServer.protocols
    mockWebServer.useHttps(SSLSocketFactory.getDefault() as SSLSocketFactory, false)
    mockWebServer.noClientAuth()
    mockWebServer.requestClientAuth()
    mockWebServer.requireClientAuth()