private final Mac digest;
    private final ReentrantLock signingLock = new ReentrantLock();
    private byte[] signingKey;
    private final String algorithmName;
    private final java.security.Provider provider;
    private volatile boolean closed = false;

    /**
     * Constructs a SMB2 signing digest with the specified session key and dialect
     *
     * @param sessionKey

     */
    static Stream<org.junit.jupiter.params.provider.Arguments> validInputs() {
        return Stream.of(org.junit.jupiter.params.provider.Arguments.of(0x0001, 0x00000000),
                org.junit.jupiter.params.provider.Arguments.of(0xFFFF, 0x12345678),
                org.junit.jupiter.params.provider.Arguments.of(-1, -123456));
    }

    @ParameterizedTest
    @MethodSource("validInputs")

  <application>
    <provider
      android:name="androidx.startup.InitializationProvider"
      android:authorities="${applicationId}.androidx-startup"
      android:exported="false"
      tools:node="merge">
      <meta-data android:name="okhttp3.internal.platform.PlatformInitializer"
                 android:value="androidx.startup"/>
    </provider>
  </application>

        provides.put(type, matcher);
    }

    @Override
    public boolean matchesRequirements(Map<String, String> requirements) {
        for (Map.Entry<String, String> requirement : requirements.entrySet()) {
            String key = requirement.getKey();

            RequirementMatcher matcher = provides.get(key);

            if (matcher == null) {

/**
 * TCP fallback RDMA provider.
 *
 * This provider uses regular TCP connections but maintains the RDMA
 * interface for compatibility. It only supports send/receive operations
 * and does not provide true RDMA read/write capabilities.
 */
public class TcpRdmaProvider implements RdmaProvider {

    /**
     * Creates a new TCP RDMA provider instance
     */
    public TcpRdmaProvider() {

    try {
      val provider = Proxy.getInvocationHandler(getMethod.invoke(null, sslSocket)) as AlpnProvider
      if (!provider.unsupported && provider.selected == null) {
        log("ALPN callback dropped: HTTP/2 is disabled. " + "Is alpn-boot on the boot class path?")
        return null
      }
      return if (provider.unsupported) null else provider.selected
    } catch (e: InvocationTargetException) {

import org.conscrypt.ConscryptHostnameVerifier

/**
 * Platform using Conscrypt (conscrypt.org) if installed as the first Security Provider.
 *
 * Requires org.conscrypt:conscrypt-openjdk-uber >= 2.1.0 on the classpath.
 */
class ConscryptPlatform private constructor() : Platform() {
  private val provider: Provider = Conscrypt.newProvider()

  // See release notes https://groups.google.com/forum/#!forum/conscrypt
  // for version differences

/**
 * DiSNI RDMA provider for InfiniBand/RoCE networks.
 *
 * This provider uses the DiSNI (Direct Storage and Networking Interface)
 * library to provide high-performance RDMA operations over InfiniBand
 * and RoCE (RDMA over Converged Ethernet) networks.
 */
public class DisniRdmaProvider implements RdmaProvider {

    /**
     * Creates a new DiSNI RDMA provider instance
     */

    private long offset; // 8 bytes: Offset within registered buffer
    private int token; // 4 bytes: RDMA provider token
    private int length; // 4 bytes: Length of buffer

    /**
     * Create SMB2 RDMA Transform
     *
     * @param offset offset within registered buffer
     * @param token RDMA provider token (steering tag/memory handle)
     * @param length length of buffer
     */

@RunWith(ParameterizedRobolectricTestRunner::class)
class AndroidSocketAdapterTest(
  val adapter: SocketAdapter,
) {
  val context: SSLContext by lazy {
    val provider: Provider = Conscrypt.newProviderBuilder().provideTrustManager(true).build()

    SSLContext.getInstance("TLS", provider).apply {
      init(null, null, null)
    }
  }

  @Test
  fun testMatchesSupportedSocket() {
    val socketFactory = context.socketFactory