*/
package okhttp3.internal.http

import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.Request

object ExternalHttp2Example {
  @JvmStatic
  fun main(args: Array<String>) {
    val client =
      OkHttpClient.Builder()
        .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
        .build()
    val call =
      client.newCall(
        Request.Builder()

      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)
    }
  }

  @Test
  fun testOkHttpSecureProxiedHttp1() {
    testRequest {
      val client =
        OkHttpClient.Builder()
          .trustMockServer()
          .proxy(Proxy(Proxy.Type.HTTP, it.remoteAddress()))
          .protocols(listOf(Protocol.HTTP_1_1))
          .build()

      val response =

      assertThat(acceptedHostName).isEqualTo(hostname)

      if (socketMode.tlsExtensionMode == STANDARD) {
        assertThat(response.protocol).isEqualTo(socketMode.protocol)
      } else {
        assertThat(response.protocol).isEqualTo(HTTP_1_1)
      }
    }
  }

  companion object {
    @Suppress("unused")
    @JvmStatic
    fun connectionTypes(): List<SocketMode> =

    enableTlsWithTunnel()
    server.protocols = Arrays.asList(Protocol.HTTP_1_1)
    responseBodyFail(Protocol.HTTP_1_1)
  }

  @Test
  fun responseBodyFailHttp2OverHttps() {
    platform.assumeHttp2Support()
    enableTlsWithTunnel()
    server.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1)
    responseBodyFail(Protocol.HTTP_2)
  }

  @Test

   */
  var protocols: List<Protocol> = immutableListOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
    set(value) {
      val protocolList = value.toImmutableList()
      require(Protocol.H2_PRIOR_KNOWLEDGE !in protocolList || protocolList.size == 1) {
        "protocols containing h2_prior_knowledge cannot use other protocols: $protocolList"
      }

        connectTls(sslSocket, connectionSpec)
        user.secureConnectEnd(handshake)
      } else {
        socket = rawSocket
        protocol =
          when {
            Protocol.H2_PRIOR_KNOWLEDGE in route.address.protocols -> Protocol.H2_PRIOR_KNOWLEDGE
            else -> Protocol.HTTP_1_1
          }
      }

      val connection =
        RealConnection(
          taskRunner = taskRunner,

                    if ("web".equalsIgnoreCase(protocolType)) {
                        addWebProtocol(protocol);
                    } else if ("file".equalsIgnoreCase(protocolType)) {
                        addFileProtocol(protocol);
                    } else {
                        logger.warn("Unknown protocol: {}", protocol);
                    }
                }
            } catch (final ClassNotFoundRuntimeException e) {

            throws IOException {
        synchronized (PROTOCOL_HANDLERS) {
            URLStreamHandler handler = (URLStreamHandler)
                    PROTOCOL_HANDLERS.get(protocol);
            if (handler != null) return handler;
            if (factory != null) {
                handler = factory.createURLStreamHandler(protocol);
            }

      assertThat(response.body.string()).isEqualTo("healthy")
    }
  }

  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client.newBuilder()
        .protocols(listOf(protocol, Protocol.HTTP_1_1))
        .build()
    server.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client.newBuilder()
        .sslSocketFactory(

    } else {
      super.configureTlsExtensions(sslSocket, hostname, protocols)
    }
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    if (sslSocket is org.openjsse.javax.net.ssl.SSLSocket) {
      when (val protocol = sslSocket.applicationProtocol) {
        // Handles both un-configured and none selected.
        null, "" -> null
        else -> protocol
      }
    } else {