/**
 * SMB2 Read request message.
 *
 * This command is used to read data from a file that has been
 * previously opened with a Create request.
 *
 * @author mbechler
 */
public class Smb2ReadRequest extends ServerMessageBlock2Request<Smb2ReadResponse> implements RequestWithFileId {

    /**
     * Flag to indicate unbuffered read operation
     */
    public static byte SMB2_READFLAG_READ_UNBUFFERED = 0x1;

import jcifs.internal.util.SMBUtil;

/**
 * Test class for Smb2ReadRequest functionality
 */
@DisplayName("Smb2ReadRequest Tests")
class Smb2ReadRequestTest {

    @Mock
    private Configuration mockConfig;

    @Mock
    private CIFSContext mockContext;

    private byte[] testFileId;
    private byte[] outputBuffer;
    private Smb2ReadRequest request;

    @BeforeEach
    void setUp() {

        }
    }

    @Test
    void testAdaptiveStrategyLargeTransfer() throws Exception {
        loadBalancer.setStrategy(LoadBalancingStrategy.ADAPTIVE);

        Smb2ReadRequest largeRead = mock(Smb2ReadRequest.class);
        when(largeRead.getReadLength()).thenReturn(2 * 1024 * 1024); // 2MB

        when(mockChannelManager.getHealthyChannels()).thenReturn(Arrays.asList(channel1, channel2));

        return selectWeightedRandom(channels);
    }

    private boolean isLargeTransfer(CommonServerMessageBlock message) {
        if (message instanceof Smb2ReadRequest) {
            return ((Smb2ReadRequest) message).getReadLength() > 1048576; // 1MB
        }
        if (message instanceof Smb2WriteRequest) {
            // Data length not accessible, assume large writes for now

import jcifs.internal.smb2.info.Smb2QueryInfoRequest;
import jcifs.internal.smb2.info.Smb2SetInfoRequest;
import jcifs.internal.smb2.io.Smb2FlushRequest;
import jcifs.internal.smb2.io.Smb2ReadRequest;
import jcifs.internal.smb2.io.Smb2WriteRequest;
import jcifs.internal.smb2.ioctl.Smb2IoctlRequest;
import jcifs.internal.smb2.lock.Smb2Lock;
import jcifs.internal.smb2.lock.Smb2LockRequest;

/**

                }

                try {
                    if (th.isSMB2()) {
                        final Smb2ReadRequest request = new Smb2ReadRequest(th.getConfig(), fd.getFileId(), b, off);
                        request.setOffset(type == SmbConstants.TYPE_NAMED_PIPE ? 0 : this.fp);
                        request.setReadLength(r);

            ArgumentCaptor<Smb2ReadRequest> cap = ArgumentCaptor.forClass(Smb2ReadRequest.class);
            verify(mockTree).send(cap.capture(), any(RequestParam.class));
            Smb2ReadRequest req = cap.getValue();

            // Reflectively inspect the private 'offset' field to assert it used the advanced fp
            Field offField = Smb2ReadRequest.class.getDeclaredField("offset");

        // Use file handle or tree ID for affinity
        long affinityKey = 0;
        
        if (message instanceof Smb2ReadRequest) {
            affinityKey = Arrays.hashCode(((Smb2ReadRequest)message).getFileId());
        } else if (message instanceof Smb2WriteRequest) {
            affinityKey = Arrays.hashCode(((Smb2WriteRequest)message).getFileId());
        }
        

            do {
                r = len > this.readSize ? this.readSize : len;

                if (th.isSMB2()) {
                    final Smb2ReadRequest request = new Smb2ReadRequest(th.getConfig(), fh.getFileId(), b, off);
                    request.setOffset(this.fp);
                    request.setReadLength(r);
                    request.setRemainingBytes(len - off);

    
    private void sendWithRdmaReadWrite(ServerMessageBlock2 request) throws IOException {
        // For large data transfers, use RDMA read/write
        
        if (request instanceof Smb2ReadRequest) {
            handleRdmaRead((Smb2ReadRequest) request);
        } else if (request instanceof Smb2WriteRequest) {
            handleRdmaWrite((Smb2WriteRequest) request);
        } else {