@Test
    @DisplayName("Test decode with buffer offset")
    void testDecodeWithBufferOffset() throws SMBProtocolDecodingException {
        // Prepare test data with offset
        byte[] buffer = new byte[20]; // Extra space to test offset
        int bufferIndex = 7; // Start at offset 7
        long expectedIndexNumber = 0xFEDCBA9876543210L;

        // Encode test data at offset

}

// ARM64RegisterListOffset generates offset encoding according to AArch64 specification.
func ARM64RegisterListOffset(firstReg, regCnt int, arrangement int64) (int64, error) {
	offset := int64(firstReg)
	switch regCnt {
	case 1:
		offset |= 0x7 << 12
	case 2:
		offset |= 0xa << 12
	case 3:
		offset |= 0x6 << 12
	case 4:
		offset |= 0x2 << 12
	default:

     * @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,

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

        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;
            }

    }

    @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);

        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);

    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() {