socket.enabledCipherSuites =
      arrayOf(
        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.javaName,
      )
    socket.enabledProtocols =
      arrayOf(
        TlsVersion.TLS_1_2.javaName,
        TlsVersion.TLS_1_1.javaName,
      )
    assertThat(tlsSpec.isCompatible(socket)).isTrue()
    socket.enabledProtocols = arrayOf(TlsVersion.TLS_1_1.javaName)

    assertArrayEquals(arrayOf("TLS_A", "TLS_C"), socket.enabledCipherSuites)
  }

  @Test
  fun applyIntersectionRetainsSslPrefixes() {
    val socket = FakeSslSocket()
    socket.enabledProtocols = arrayOf("TLSv1")
    socket.supportedCipherSuites =
      arrayOf("TLS_A", "TLS_B", "TLS_C", "TLS_D", "TLS_E")
    socket.enabledCipherSuites = arrayOf("TLS_A", "TLS_B", "TLS_C")
    val connectionSpec =

		}},
	}
}

// New returns a new empty Array.
func (p *ArrayOf[T]) New() *Array[T] {
	return &Array[T]{
		p: p,
	}
}

// NewWith returns a new Array with the provided value (not copied).
func (p *ArrayOf[T]) NewWith(val []T) *Array[T] {
	return &Array[T]{
		p:   p,
		val: val,
	}
}

func (p *ArrayOf[T]) newA(sz uint32) []T {
	t, ok := p.aPool.Get().(*[]T)

    }
  }

  class FakeSSLSession(
    private val protocol: String,
    private val cipherSuite: String,
    private val peerCertificates: Array<Certificate>?,
    private val localCertificates: Array<Certificate>?,
  ) : DelegatingSSLSession(null) {
    override fun getProtocol() = protocol

    override fun getCipherSuite() = cipherSuite

  ) {
    responder(Request(network, domain, nsType, flags, callback))
  }

  companion object {
    @Implementation
    @JvmStatic
    fun getInstance(): DnsResolver = Shadow.newInstance(DnsResolver::class.java, arrayOf(), arrayOf())
  }

    val keyManager = keyManagerFactory.keyManagers[0] as X509ExtendedKeyManager

    val trustManager = Platform.get().platformTrustManager()

    val sslContext = SSLContext.getInstance("TLS")
    sslContext.init(arrayOf(keyManager), arrayOf(trustManager), SecureRandom())

    val client =
      OkHttpClient
        .Builder()
        .sslSocketFactory(sslContext.socketFactory, trustManager)
        .build()

        override fun checkClientTrusted(
          chain: Array<X509Certificate>,
          authType: String,
        ) {
        }

        override fun checkServerTrusted(
          chain: Array<X509Certificate>,
          authType: String,
        ) {
        }

        override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
      }

import java.util.Properties


@DisableCachingByDefault(because = "Not worth caching")
abstract class UpdateInitPluginTemplateVersionFile : DefaultTask() {

    private
    val devSuffixes = arrayOf(
        "-SNAP\\d+",
        "-SNAPSHOT",
        "-alpha.*\\d+",
        "-beta.*\\d+",
        "-dev-?\\d+",
        "-dev-\\d+-\\d+",
        "-rc(-?\\d+)?",
        "-M.+",
        "-eap-?\\d+"

  fun sslContext(): SSLContext =
    Platform.get().newSSLContext().apply {
      init(arrayOf<KeyManager>(keyManager), arrayOf<TrustManager>(trustManager), SecureRandom())
    }

  class Builder {
    private var heldCertificate: HeldCertificate? = null
    private var intermediates: Array<X509Certificate>? = null
    private val trustedCertificates = mutableListOf<X509Certificate>()

        override fun checkClientTrusted(
          chain: Array<out X509Certificate>?,
          authType: String?,
        ) {}

        override fun checkServerTrusted(
          chain: Array<out X509Certificate>?,
          authType: String?,
        ) {}

        override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
      }

    val sslContext =