val client = makeClient(ConnectionSpec.RESTRICTED_TLS, TlsVersion.TLS_1_2)

    val handshake = makeRequest(client)

    assertThat(handshake.cipherSuite).isIn(*expectedModernTls12CipherSuites.toTypedArray())

    // Probably something like
    // TLS_AES_128_GCM_SHA256
    // TLS_AES_256_GCM_SHA384
    // TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
    // TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256

      }

    fun cipherSuites(vararg cipherSuites: CipherSuite): Builder =
      apply {
        require(tls) { "no cipher suites for cleartext connections" }
        val strings = cipherSuites.map { it.javaName }.toTypedArray()
        return cipherSuites(*strings)
      }

    fun cipherSuites(vararg cipherSuites: String) =
      apply {
        require(tls) { "no cipher suites for cleartext connections" }

  @SuppressSignatureCheck
  override fun clean(
    chain: List<Certificate>,
    hostname: String,
  ): List<Certificate> {
    val certificates = (chain as List<X509Certificate>).toTypedArray()
    try {
      return x509TrustManagerExtensions.checkServerTrusted(certificates, "RSA", hostname)
    } catch (ce: CertificateException) {
      throw SSLPeerUnverifiedException(ce.message).apply { initCause(ce) }

            v1 = internalSource,
            v2 = publicSource
        ).apply {
            assertHasErrors(
                *reportedMembers.map {
                    added(it.first, it.second)
                }.toTypedArray()
            )
            assertHasNoWarning()
            assertHasNoInformation()
        }
    }

    @Test
    fun `existing public members made internal appear as removed`() {

      while (true) {
        val line = source.readUtf8Line() ?: break
        if (line.isEmpty() || line.startsWith("#")) continue

        var i = 0
        val parts = line.split(Regex(" ")).toTypedArray()

        val element = WebPlatformUrlTestData()
        element.input = unescape(parts[i++])

        val base = if (i < parts.size) parts[i++] else null
        element.base =
          when {

      expectedCipherSuites.add("TLS_FALLBACK_SCSV")
    }
    assertThat(socket.enabledCipherSuites)
      .containsExactly(*expectedCipherSuites.toTypedArray())
  }

  @Test
  fun tls_explicitCiphers() {
    platform.assumeNotConscrypt()
    platform.assumeNotBouncyCastle()
    val tlsSpec =
      ConnectionSpec.Builder(true)

        else -> token
      }

    parameterNamesAndValues += name
    parameterNamesAndValues += value
    s = parameter.range.last + 1
  }

  return MediaType(this, type, subtype, parameterNamesAndValues.toTypedArray())
}

/** Returns a media type for this, or null if this is not a well-formed media type. */
fun String.commonToMediaTypeOrNull(): MediaType? {
  return try {
    commonToMediaType()

      try {
        readStory(story00)
        result.add(path.name)
      } catch (ignored: IOException) {
        // Skip this path.
      }
    }
    return result.toTypedArray<String>()
  }

  /**
   * Reads stories named "story_xx.json" from the folder provided.
   */
  fun readStories(testFolderName: String): List<Story> {
    val result = mutableListOf<Story>()
    var i = 0

      if (sslParameters is org.openjsse.javax.net.ssl.SSLParameters) {
        // Enable ALPN.
        val names = alpnProtocolNames(protocols)
        sslParameters.applicationProtocols = names.toTypedArray()

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

    val classpath = System.getProperty("java.class.path")
    val entries =
      classpath.split(File.pathSeparator.toRegex())
        .dropLastWhile { it.isEmpty() }
        .toTypedArray()
    for (classPathEntry in entries) {
      deployFile(classPathEntry.toPath())
    }
  }

  private fun RepositoryPlugin.deployFile(file: Path) {