}

    @Test
    public void testCreateProviderTcp() {
        RdmaProvider provider = RdmaProviderFactory.createProvider("tcp");
        assertNotNull(provider, "TCP provider should always be available");
        assertTrue(provider.isAvailable(), "TCP provider should be available");
        assertEquals("TCP Fallback", provider.getProviderName());
    }

    @Test
    public void testCreateProviderDisni() {

import jcifs.internal.smb2.rdma.RdmaProvider;

/**
 * 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
     */

 */
package jcifs.internal.smb2.rdma.tcp;

import java.nio.ByteBuffer;
import java.util.EnumSet;
import java.util.concurrent.atomic.AtomicInteger;

import jcifs.internal.smb2.rdma.RdmaAccess;
import jcifs.internal.smb2.rdma.RdmaMemoryRegion;

/**
 * TCP memory region implementation.
 *
 * For TCP fallback, memory regions are just wrappers around

}
```

#### 4.5.2 Fallback TCP Provider
```java
package jcifs.internal.smb2.rdma.tcp;

public class TcpRdmaProvider implements RdmaProvider {
    @Override
    public boolean isAvailable() {
        return true;  // TCP is always available
    }
    
    @Override
    public Set<RdmaCapability> getSupportedCapabilities() {
        // TCP fallback only supports send/receive

import jcifs.internal.smb2.rdma.RdmaMemoryRegion;

/**
 * Unit tests for TCP RDMA provider
 */
public class TcpRdmaProviderTest {

    private TcpRdmaProvider provider;

    @BeforeEach
    public void setUp() {
        provider = new TcpRdmaProvider();
    }

    @Test
    public void testIsAvailable() {
        assertTrue(provider.isAvailable(), "TCP provider should always be available");
    }

    @Test

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.Configuration;
import jcifs.internal.smb2.rdma.disni.DisniRdmaProvider;
import jcifs.internal.smb2.rdma.tcp.TcpRdmaProvider;

/**
 * Factory for creating RDMA provider instances.
 *
 * This factory attempts to select the best available RDMA provider
 * based on system capabilities and configuration preferences.
 */

After this, the client and the server have an **encrypted TCP connection**, this is what TLS provides. And then they can use that connection to start the actual **HTTP communication**.

And that's what **HTTPS** is, it's just plain **HTTP** inside a **secure TLS connection** instead of a pure (unencrypted) TCP connection.

/// tip

            throw new IOException("TCP RDMA receive failed", e);
        }
    }

    @Override
    public void rdmaRead(RdmaMemoryRegion localRegion, long remoteAddress, int remoteKey, int length) throws IOException {
        // TCP fallback doesn't support real RDMA read
        throw new UnsupportedOperationException("RDMA read not supported by TCP fallback");
    }

    @Override

        props.setProperty("jcifs.smb.client.useRDMA", "true");
        props.setProperty("jcifs.smb.client.rdmaProvider", "tcp");

        PropertyConfiguration config = new PropertyConfiguration(props);

        assertTrue(config.isUseRDMA(), "RDMA should be enabled");
        assertEquals("tcp", config.getRdmaProvider(), "Provider should be tcp");
    }

    @Test
    public void testRdmaAutoProvider() throws CIFSException {

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.internal.smb2.rdma.tcp.TcpMemoryRegion;

/**
 * Unit tests for RDMA buffer manager
 */
public class RdmaBufferManagerTest {

    @Mock
    private RdmaProvider mockProvider;

    private RdmaBufferManager bufferManager;