// Verify notify flags
        assertEquals(Smb2ChangeNotifyRequest.SMB2_WATCH_TREE, SMBUtil.readInt2(buffer, offset + 2));

        // Verify output buffer length
        assertEquals(8192, SMBUtil.readInt4(buffer, offset + 4));

        // Verify file ID
        byte[] readFileId = new byte[16];
        System.arraycopy(buffer, offset + 8, readFileId, 0, 16);

			"SELECT * FROM `users` LIMIT ?",
			[]interface{}{limit10},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Limit{Limit: &limit10, Offset: 20}, clause.Limit{Offset: 30}, clause.Limit{Limit: &limitNeg10}},
			"SELECT * FROM `users` OFFSET ?",
			[]interface{}{30},
		},
		{

        // Length = 5, Offset = 8
        ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort(0, (short) content.length); // Length
        buffer.putShort(2, (short) content.length); // MaxLength (not used by readSecurityBuffer, but typically same as length)
        buffer.putInt(4, 8); // Offset

  }

  private static long hashLength33To64(byte[] bytes, int offset, int length) {
    long z = load64(bytes, offset + 24);
    long a = load64(bytes, offset) + (length + load64(bytes, offset + length - 16)) * K0;
    long b = rotateRight(a + z, 52);
    long c = rotateRight(a, 37);
    a += load64(bytes, offset + 8);
    c += rotateRight(a, 7);
    a += load64(bytes, offset + 16);
    long vf = a + z;

     */
    public static final int SMB2_LOCKFLAG_FAIL_IMMEDIATELY = 0x10;

    private final long offset;
    private final long length;
    private final int flags;

    /**
     * Constructs an SMB2 lock element with the specified parameters.
     *
     * @param offset the byte offset in the file where the lock begins
     * @param length the number of bytes to lock

        this.readLength = readLength;
    }

    /**
     * Sets the file offset from which to start reading
     *
     * @param offset
     *            the offset to set
     */
    public void setOffset(final long offset) {
        this.offset = offset;
    }

    /**
     * Sets the minimum number of bytes that must be read for the operation to succeed
     *

	}

	// To generate random offset/length.
	r := rand.New(rand.NewSource(UTCNow().UnixNano()))

	buf := &bytes.Buffer{}

	// Verify erasure.Decode() for random offsets and lengths.
	for range iterations {
		offset := r.Int63n(length)
		readLen := r.Int63n(length - offset)

		expected := data[offset : offset+readLen]

		// Get the checksums of the current part.

    /**
     * Return the byte or character offset into the input source this location
     * is pointing to. If the input source is a file or a byte stream then
     * this is the byte offset into that stream, but if the input source is
     * a character media then the offset is the character offset.
     * Returns -1 if there is no offset available.
     * @return the current offset
     */
    int getCharacterOffset();

    /**

        }

        @Test
        @DisplayName("Should decode at non-zero offset")
        void testDecodeWithOffset() throws SMBProtocolDecodingException {
            int offset = 50;
            SMBUtil.writeInt2(1, buffer, offset);
            SMBUtil.writeInt2(EncryptionNegotiateContext.CIPHER_AES128_GCM, buffer, offset + 2);

            EncryptionNegotiateContext context = new EncryptionNegotiateContext();

        this.offset = offset;
        this.maxCount = minCount = maxCount;
        command = SMB_COM_READ_ANDX;
        openTimeout = 0xFFFFFFFF;
    }

    void setParam(final int fid, final long offset, final int maxCount) {
        this.fid = fid;
        this.offset = offset;
        this.maxCount = minCount = maxCount;
    }

    @Override
    int getBatchLimit(final byte command) {