@Suppress("DEPRECATION")
      return when (protocol) {
        HTTP_1_0.protocol -> HTTP_1_0
        HTTP_1_1.protocol -> HTTP_1_1
        H2_PRIOR_KNOWLEDGE.protocol -> H2_PRIOR_KNOWLEDGE
        HTTP_2.protocol -> HTTP_2
        SPDY_3.protocol -> SPDY_3
        QUIC.protocol -> QUIC
        else -> {
          // Support HTTP3 draft like h3-29

            sslSocketFactory(
              sslSocketFactory,
              handshakeCertificates.trustManager,
            )

            when (socketMode.protocol) {
              HTTP_2 -> protocols(listOf(HTTP_2, HTTP_1_1))
              HTTP_1_1 -> protocols(listOf(HTTP_1_1))
              else -> TODO()
            }

            val serverSslSocketFactory =

 */
package okhttp3.internal.authenticator

import java.net.Authenticator
import java.net.InetAddress
import junit.framework.TestCase.assertNull
import okhttp3.FakeDns
import okhttp3.Protocol.HTTP_2
import okhttp3.Request
import okhttp3.Response
import okhttp3.TestValueFactory
import okhttp3.internal.RecordingAuthenticator
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals

import java.security.Provider
import javax.net.ssl.SSLContext
import javax.net.ssl.SSLSocket
import okhttp3.DelegatingSSLSocket
import okhttp3.DelegatingSSLSocketFactory
import okhttp3.Protocol.HTTP_1_1
import okhttp3.Protocol.HTTP_2
import okhttp3.testing.PlatformRule
import org.conscrypt.Conscrypt
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue

  }

  @Test
  fun serverTruncatesRequestOnLongPostHttp1() {
    serverTruncatesRequestOnLongPost(https = false)
  }

  @Test
  fun serverTruncatesRequestOnLongPostHttp2() {
    enableProtocol(Protocol.HTTP_2)
    serverTruncatesRequestOnLongPost(https = true)
  }

  private fun serverTruncatesRequestOnLongPost(https: Boolean) {
    server.enqueue(
      MockResponse(
        body = "abc",

        val sslSocket = doSsl(socket)
        val protocolString = Platform.get().getSelectedProtocol(sslSocket)
        val protocol = if (protocolString != null) get(protocolString) else null
        if (protocol != Protocol.HTTP_2) {
          throw ProtocolException("Protocol $protocol unsupported")
        }
        val connection =
          Http2Connection.Builder(false, TaskRunner.INSTANCE)
            .socket(sslSocket)

    assertThat(get("http/1.0")).isEqualTo(Protocol.HTTP_1_0)
    assertThat(get("http/1.1")).isEqualTo(Protocol.HTTP_1_1)
    assertThat(get("spdy/3.1")).isEqualTo(Protocol.SPDY_3)
    assertThat(get("h2")).isEqualTo(Protocol.HTTP_2)
    assertThat(get("h2_prior_knowledge")).isEqualTo(Protocol.H2_PRIOR_KNOWLEDGE)
    assertThat(get("quic")).isEqualTo(Protocol.QUIC)
    assertThat(get("h3")).isEqualTo(Protocol.HTTP_3)

      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
      assertEquals(TlsVersion.TLS_1_3, response.handshake?.tlsVersion)
      assertEquals(Protocol.HTTP_2, response.protocol)

      assertThat(response.exchangeAccessor!!.connectionAccessor.socket())
        .isInstanceOf<SSLSocketImpl>()
    }
  }

  @Test
  fun testSupportedProtocols() {

      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)