import javax.net.ssl.X509TrustManager
import okhttp3.Protocol
import okhttp3.internal.SuppressSignatureCheck

/** OpenJDK 9+. */
open class Jdk9Platform : Platform() {
  @SuppressSignatureCheck
  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<@JvmSuppressWildcards Protocol>,
  ) {
    val sslParameters = sslSocket.sslParameters

				Name:    httpName,
			}
			if port.Protocol.IsUnsupported() {
				// If we need to sniff, insert two chains and the protocol detector
				chains = append(chains, tcpChain, httpChain)
				portMapper.Map[portString] = match.ToMatcher(match.NewAppProtocol(match.ProtocolMatch{
					TCP:  match.ToChain(tcpName),
					HTTP: match.ToChain(httpName),
				}))
			} else if port.Protocol.IsHTTP() {
				// Otherwise, just insert HTTP/TCP

// before the stream begins reading.
//
// The protocols parameter maps subprotocol names to StreamProtocols. The empty string
// subprotocol name is used if websocket.Config.Protocol is empty.
func NewReader(r io.Reader, ping bool, protocols map[string]ReaderProtocolConfig) *Reader {
	return &Reader{
		r:           r,
		err:         make(chan error),
		ping:        ping,
		protocols:   protocols,
		handleCrash: runtime.HandleCrash,
	}
}

        }
        throw new InsecureProtocolException(
            "Redirecting from secure protocol to insecure protocol, without explicit opt-in, is unsupported." + contextualAdvice,
            String.format("Switch %s repository '%s' to redirect to a secure protocol (like HTTPS) or allow insecure protocols. ", repositoryType, displayNameSupplier.get()),

 */
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.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(

    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

		{25, "", nil, corev1.ProtocolTCP, protocol.TCP},
		{53, "", nil, corev1.ProtocolTCP, protocol.TCP},
		{3306, "", nil, corev1.ProtocolTCP, protocol.TCP},
		{27017, "", nil, corev1.ProtocolTCP, protocol.TCP},
		{8888, "http", nil, corev1.ProtocolTCP, protocol.HTTP},
		{8888, "http-test", nil, corev1.ProtocolTCP, protocol.HTTP},
		{8888, "http", nil, corev1.ProtocolUDP, protocol.UDP},

// Mongo and MySQL are not allowed to co-exist with other protocols in one port.
func isConflictWithWellKnownPort(incoming, existing protocol.Instance, conflict int) bool {
	if conflict == NoConflict {
		return true
	}

	if (incoming == protocol.Mongo ||
		incoming == protocol.MySQL ||
		existing == protocol.Mongo ||

            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 =