byte[] data = "Hello World Test".getBytes();
            InputStream is = new ByteArrayInputStream(data);
            byte[] buffer = new byte[20];

            int bytesRead = Transport.readn(is, buffer, 0, 5);
            assertEquals(5, bytesRead);
            assertArrayEquals("Hello".getBytes(), java.util.Arrays.copyOfRange(buffer, 0, 5));
        }

        @Test

            long startTime = System.nanoTime();

            int bytesRead = rdmaConnection.read(buffer, remoteAddress, remoteKey, length);

            long duration = System.nanoTime() - startTime;
            statistics.recordReadSuccess(bytesRead, duration);

            return bytesRead;
        } catch (IOException e) {
            statistics.recordReadError();
            throw e;

        setErrorCode(response, 0);

        int bytesRead = response.readDataWireFormat(fullBuffer, startIndex, buffer.length);

        // Verify the method returns the correct number of bytes read
        assertTrue(bytesRead > 0);
        assertTrue(bytesRead <= buffer.length);
    }

    /**
     * Helper method to create a valid security descriptor buffer

                return null;
            }
        }).when(smbFile).send(any(SmbComReadAndX.class), any(SmbComReadAndXResponse.class));

        int bytesRead = smbRandomAccessFile.read(buffer);
        assertEquals(10, bytesRead);
        assertArrayEquals(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, buffer);
        assertEquals(10, smbRandomAccessFile.getFilePointer());
    }

    @Test

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int bytesRead;

            while ((bytesRead = inflaterStream.read(buffer)) != -1) {
                baos.write(buffer, 0, bytesRead);
            }

            inflaterStream.close();
            return baos.toByteArray();
        } catch (IOException e) {

            buffer[14] = 0x1F;
            buffer[15] = 0x00;

            // When
            int bytesRead = (int) invokeMethod(response, "readBytesWireFormat", new Class[] { byte[].class, int.class }, buffer, 0);

            // Then
            assertEquals(16, bytesRead, "Should read 16 bytes");

            paramWordsRead = 10;
            return paramWordsRead;
        }

        @Override
        int readBytesWireFormat(byte[] buffer, int bufferIndex) {
            bytesRead = 20;
            return bytesRead;
        }

        // Allow tests to control batching limit
        @Override
        int getBatchLimit(byte command) {
            return customBatchLimit != null ? customBatchLimit : 0;

            bytesRead = 20;
            return bytesRead;
        }

        public void setParamWordsRead(int value) {
            this.paramWordsRead = value;
        }

        public void setBytesRead(int value) {
            this.bytesRead = value;
        }

        public int getWordCount() {
            return wordCount;

                new Trans2QueryPathInformationResponse(Trans2QueryPathInformationResponse.SMB_QUERY_FILE_BASIC_INFO) {
                };
        int bytesRead = trans.readDataWireFormat(buffer, 0, buffer.length);
        assertEquals(buffer.length, bytesRead);
        // Access private field 'info'
        java.lang.reflect.Field infoField = Trans2QueryPathInformationResponse.class.getDeclaredField("info");

            assertEquals(1024, stream.available());

            byte[] readBuffer = new byte[1024];
            int bytesRead = stream.read(readBuffer);

            assertEquals(1024, bytesRead);
            for (int i = 0; i < data.length; i++) {
                assertEquals("Mismatch at position " + i, data[i], readBuffer[i]);
            }
        }
    }