* @param offset the file offset at which to write
     * @param remaining the number of bytes remaining to be written
     * @param b the data buffer containing bytes to write
     * @param off the offset in the buffer where data starts
     * @param len the number of bytes to write
     */
    public SmbComWrite(final Configuration config, final int fid, final int offset, final int remaining, final byte[] b, final int off,

        if (startPosition * 2 >= windowSize) {
            int offset = params.getOffset();
            if (offset < 0) {
                offset = 0;
            } else if (offset > windowSize / 2) {
                offset = windowSize / 2;
            }
            int start = startPosition - offset;
            if (start < 0) {
                start = 0;
            }

     */
    public Smb2RdmaTransform(long offset, int token, int length) {
        this.offset = offset;
        this.token = token;
        this.length = length;
    }

    /**
     * Get buffer offset
     *
     * @return offset within registered buffer
     */
    public long getOffset() {
        return offset;
    }

    /**
     * Get RDMA token
     *
     * @return RDMA provider token

        byte[] buffer = new byte[10];
        int offset = 2;

        // Act
        int bytesWritten = transPeekNamedPipe.writeSetupWireFormat(buffer, offset);

        // Assert
        assertEquals(4, bytesWritten);
        assertEquals(SmbComTransaction.TRANS_PEEK_NAMED_PIPE, buffer[offset]);
        assertEquals((byte) 0x00, buffer[offset + 1]);

        // Verify FID is written correctly (little-endian)

    }

    @Test
    @DisplayName("Should format with specific offset and length")
    void testHexdumpWithOffsetAndLength() {
        // Given
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        // When
        String result = Hexdump.toHexString(data, offset, length);

        // Then
        assertNotNull(result);

     */
    public LockingAndXRange(final boolean largeFile) {
        this.largeFile = largeFile;
    }

    /**
     * Returns the process ID associated with this lock range.
     *
     * @return the process ID
     */
    public int getPid() {
        return this.pid;
    }

    /**
     * Returns the starting byte offset of the lock range.
     *

        final int offset = readULong(src, index + 4);
        final byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(final byte[] dest, final int offset, final int ulong) {
        dest[offset] = (byte) (ulong & 0xff);
        dest[offset + 1] = (byte) (ulong >> 8 & 0xff);

        @DisplayName("Should encode with offset correctly")
        void testEncodeWithOffset() {
            String path = "\\\\test";
            int maxReferralLevel = 5;
            buffer = new DfsReferralRequestBuffer(path, maxReferralLevel);

            int offset = 10;
            byte[] dst = new byte[offset + buffer.size()];
            int bytesEncoded = buffer.encode(dst, offset);

            assertEquals(ttl, ref.getTtl());
        }
    }

    // Buffer Offset Tests

    @Test
    public void testDecodeFromNonZeroIndex() {
        int offset = 100;
        ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

        bb.position(offset);
        bb.putShort((short) 1);
        bb.putShort((short) 24);
        bb.putShort((short) 1);

    private long offset;

    /**
     * Constructs a seek response.
     *
     * @param config the configuration
     */
    public SmbComSeekResponse(final Configuration config) {
        super(config);
    }

    /**
     * Gets the current file offset after the seek operation.
     *
     * @return the offset
     */
    public long getOffset() {