String sessionId = "test-session-3";
        keyManager.storeSessionKey(sessionId, testKey, "AES");

        assertTrue(keyManager.hasSessionKey(sessionId), "Key should exist");

        keyManager.removeSessionKey(sessionId);

        assertFalse(keyManager.hasSessionKey(sessionId), "Key should be removed");
        assertNull(keyManager.getSessionKey(sessionId), "Should not retrieve removed key");
    }

  @get:JvmName("keyManager") val keyManager: X509KeyManager,
  @get:JvmName("trustManager") val trustManager: X509TrustManager,
) {
  @JvmName("-deprecated_keyManager")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "keyManager"),
    level = DeprecationLevel.ERROR,
  )
  fun keyManager(): X509KeyManager = keyManager

  @JvmName("-deprecated_trustManager")

     *            key for server->client decryption
     * @param keyManager
     *            secure key manager
     */
    public Smb2EncryptionContext(final int cipherId, final DialectVersion dialect, final byte[] encryptionKey, final byte[] decryptionKey,
            final SecureKeyManager keyManager) {
        this(cipherId, dialect, encryptionKey, decryptionKey, keyManager, null, null);
    }

    /**

        .heldCertificate(certificate, intermediate.certificate)
        .build()
    assertPrivateKeysEquals(
      certificate.keyPair.private,
      handshakeCertificates.keyManager.getPrivateKey("private"),
    )
    assertThat(handshakeCertificates.keyManager.getCertificateChain("private").toList())
      .isEqualTo(listOf(certificate.certificate, intermediate.certificate))
  }

  @Test fun platformTrustedCertificates() {

          emptyList(),
        )
      val sslContext = SSLContext.getInstance("TLS")
      sslContext.init(
        arrayOf<KeyManager>(keyManager),
        arrayOf<TrustManager>(trustManager),
        SecureRandom(),
      )
      sslContext.socketFactory
    } catch (e: GeneralSecurityException) {
      throw AssertionError(e)
    }
  }

    keyManagerFactory.init(KeyStoreBuilderParameters(builderList))
    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()

        assertArrayEquals(plaintext, decrypted);

        // Cleanup
        context.close();
        keyManager.close();
    }

    @Test
    @DisplayName("Should properly close and wipe keys with SecureKeyManager")
    void testCloseWithSecureKeyManager() {
        // Given
        SecureKeyManager keyManager = new SecureKeyManager();
        byte[] encKey = new byte[16];
        byte[] decKey = new byte[16];

    val parse: HttpUrl? = HttpUrl.parse("")
  }

  @Test @Disabled
  fun handshakeCertificates() {
    val handshakeCertificates = HandshakeCertificates.Builder().build()
    val keyManager: X509KeyManager = handshakeCertificates.keyManager()
    val trustManager: X509TrustManager = handshakeCertificates.trustManager()
  }

  @Test @Disabled
  fun handshakeCertificatesBuilder() {

	public final fun -deprecated_trustManager ()Ljavax/net/ssl/X509TrustManager;
	public synthetic fun <init> (Ljavax/net/ssl/X509KeyManager;Ljavax/net/ssl/X509TrustManager;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
	public final fun keyManager ()Ljavax/net/ssl/X509KeyManager;
	public final fun sslContext ()Ljavax/net/ssl/SSLContext;
	public final fun sslSocketFactory ()Ljavax/net/ssl/SSLSocketFactory;
	public final fun trustManager ()Ljavax/net/ssl/X509TrustManager;

import assertk.assertions.isEqualTo
import assertk.assertions.startsWith
import java.io.IOException
import java.security.SecureRandom
import java.security.cert.X509Certificate
import javax.net.ssl.KeyManager
import javax.net.ssl.SSLHandshakeException
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.TrustManager
import kotlin.test.assertFailsWith