int offset = 0;
        int size = 3;

        // Simulate successful verification
        when(mockResponse.verifySignature(buffer, offset, size)).thenReturn(true);
        assertTrue(mockResponse.verifySignature(buffer, offset, size));

        // Simulate failed verification
        when(mockResponse.verifySignature(buffer, offset, size)).thenReturn(false);

            // Reflectively inspect the private 'offset' field to assert it used the advanced fp
            Field offField = Smb2ReadRequest.class.getDeclaredField("offset");
            offField.setAccessible(true);
            long offVal = offField.getLong(req);
            assertEquals(2L, offVal, "Request offset should match skipped bytes");
        }

        @Test

    delegateList.forEach(action);
  }

  @GwtIncompatible // not present in emulated superclass
  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    return delegateList.copyIntoArray(dst, offset);
  }

  @Override
  Object @Nullable [] internalArray() {
    return delegateList.internalArray();
  }

  @Override
  int internalArrayStart() {

     */
    public final void setMode(final int mode) {
        this.mode = mode;
    }

    /**
     * Sets the seek offset.
     *
     * @param offset
     *            the offset to set
     */
    public final void setOffset(final long offset) {
        this.offset = offset;
    }

    /**
     * {@inheritDoc}
     *

 *
 * ```
 *  0..63 : Length of the UTF-16 sequence that this range maps to. The offset is b2b3.
 * 64..79 : Offset by a fixed negative offset. The bottom 4 bits of b1 are the top 4 bits of the offset.
 * 80..95 : Offset by a fixed positive offset. The bottom 4 bits of b1 are the top 4 bits of the offset.
 *    119 : Ignored.
 *    120 : Valid.
 *    121 : Disallowed
 *    122 : Mapped inline to the sequence: [b2].

        final int ownerUOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to owner sid
        bufferIndex += 4;
        final int ownerGOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to group sid
        bufferIndex += 4;
        final int saclOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to sacl
        bufferIndex += 4;

     * @param data
     *            The data.
     * @param offset
     *            The starting offset at which the SMB header begins.
     * @param length
     *            The length of the SMB data starting at offset.
     * @param request
     *            request message
     * @param response
     *            response message
     */

        @Test
        @DisplayName("Should handle offset correctly in verify")
        void testVerifyWithOffset() throws Exception {
            byte[] largeData = new byte[256];
            int offset = 64;
            Arrays.fill(largeData, (byte) 0x00);

            // Set signed flag at correct offset
            SMBUtil.writeInt4(ServerMessageBlock2.SMB2_FLAGS_SIGNED, largeData, offset + 16);

            // Create valid signature

    }

    @Test
    @DisplayName("Test decode with offset")
    void testDecodeWithOffset() throws SMBProtocolDecodingException {
        // Prepare buffer with offset
        long expectedValue = 0xAAAABBBBCCCCDDDDL;
        byte[] buffer = new byte[20];
        int offset = 7;
        SMBUtil.writeInt8(expectedValue, buffer, offset);

        // Decode from offset

}

func (d *Decoder) emitAny() (any, error) {
	if d.pos >= atomic.LoadInt64(&d.end) {
		return nil, d.mkError(ErrUnexpectedEOF)
	}
	offset := d.pos - 1
	i, t, err := d.any()
	if d.willEmit() {
		d.metaCh <- &MetaValue{
			Offset:    int(offset),
			Length:    int(d.pos - offset),
			Depth:     d.depth,
			Value:     i,
			ValueType: t,
		}
	}
	return i, err
}