is RSAPrivateKey ->
          AlgorithmIdentifier(
            algorithm = SHA256_WITH_RSA_ENCRYPTION,
            parameters = null,
          )
        else ->
          AlgorithmIdentifier(
            algorithm = SHA256_WITH_ECDSA,
            parameters = ByteString.EMPTY,
          )
      }
    }

    private fun generateKeyPair(): KeyPair {

 *
 * See [NativeCrypto.java][conscrypt_providers] which lists the cipher suites supported by
 * Conscrypt.
 *
 * [iana_tls_parameters]: https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml
 * [sslengine]: https://developer.android.com/reference/javax/net/ssl/SSLEngine.html
 * [oracle_providers]: https://docs.oracle.com/javase/10/security/oracle-providers.htm

    assertEquals("utf-8", mediaType.parameter("charset"))
    assertEquals("1", mediaType.parameter("a"))
    assertEquals("2", mediaType.parameter("b"))
    assertEquals("3", mediaType.parameter("c"))
    assertEquals("utf-8", mediaType.parameter("CHARSET"))
    assertEquals("1", mediaType.parameter("A"))
    assertEquals("2", mediaType.parameter("B"))
    assertEquals("3", mediaType.parameter("C"))
  }

     *    }
     * ```
     *
     * This method works like [X509TrustManager.checkServerTrusted] but it receives the hostname of
     * the server as an extra parameter. Regardless of what checks this method performs, OkHttp will
     * always check that the server's certificates match its hostname using the [HostnameVerifier].

      algorithmParameters,
      decompose = {
        listOf(
          it.algorithm,
          it.parameters,
        )
      },
      construct = {
        AlgorithmIdentifier(
          algorithm = it[0] as String,
          parameters = it[1],
        )
      },
    )

  /**
   * ```
   * BasicConstraints ::= SEQUENCE {

/**
 * Listener for connection events. Extend this class to monitor the new connections and closes.
 *
 * All event methods must execute fast, without external locking, cannot throw exceptions,
 * attempt to mutate the event parameters, or be reentrant back into the client.
 * Any IO - writing to files or network should be done asynchronously.
 */
@ExperimentalOkHttpApi
abstract class ConnectionListener {
  /**

    val charset = parameter("charset") ?: return defaultValue
    return try {
      Charset.forName(charset)
    } catch (_: IllegalArgumentException) {
      defaultValue // This charset is invalid or unsupported. Give up.
    }
  }

  /**
   * Returns the parameter [name] of this media type, or null if this media type does not define
   * such a parameter.
   */

  fun emptyCache(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)
    cache.close()
    assertJournalEquals()
  }

  @ParameterizedTest
  @ArgumentsSource(FileSystemParamProvider::class)
  fun recoverFromInitializationFailure(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)

      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        val parameters = sslSocket.sslParameters
        Log.d("CustomSSLSocketFactory", "old applicationProtocols: $parameters.applicationProtocols")
        parameters.applicationProtocols = arrayOf("x-amzn-http-ca")
        sslSocket.sslParameters = parameters
      }

      return sslSocket
    }
  }

  var client = OkHttpClient()

  @Test

	public fun equals (Ljava/lang/Object;)Z
	public static final fun get (Ljava/lang/String;)Lokhttp3/MediaType;
	public fun hashCode ()I
	public final fun parameter (Ljava/lang/String;)Ljava/lang/String;
	public static final fun parse (Ljava/lang/String;)Lokhttp3/MediaType;
	public final fun subtype ()Ljava/lang/String;
	public fun toString ()Ljava/lang/String;