SessionServicePacket.writeInt2(value, dst, 0);

        assertEquals((byte) ((value >> 8) & 0xFF), dst[0]);
        assertEquals((byte) (value & 0xFF), dst[1]);
    }

    @Test
    @DisplayName("writeInt2 with offset should write at correct position")
    void testWriteInt2WithOffset() {
        byte[] dst = new byte[10];
        dst[2] = (byte) 0xFF; // Mark position
        dst[3] = (byte) 0xFF;

	return p.storage.ListDir(ctx, origvolume, volume, dirPath, count)
}

// Legacy API - does not have any deadlines
func (p *xlStorageDiskIDCheck) ReadFile(ctx context.Context, volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error) {
	ctx, done, err := p.TrackDiskHealth(ctx, storageMetricReadFile, volume, path)
	if err != nil {
		return 0, err
	}
	defer func() {
		done(n, &err)

	if !st.Mode().IsRegular() {
		file.Close()
		return nil, errIsNotRegular
	}

	if st.Size() < offset+length {
		// Expected size cannot be satisfied for
		// requested offset and length
		file.Close()
		return nil, errFileCorrupt
	}

	if offset > 0 {
		if _, err = file.Seek(offset, io.SeekStart); err != nil {
			file.Close()
			return nil, err
		}
	}

                                        </div>
                                    </div>
                                    <div class="form-group row">
                                        <div class="offset-sm-2 col-sm-10">
                                            <button type="submit" class="btn btn-primary" id="submit"
                                                    name="search"

                                        </div>
                                    </div>
                                    <div class="form-group row">
                                        <div class="offset-sm-2 col-sm-10">
                                            <button type="submit" class="btn btn-primary" id="submit"
                                                    name="search"

     *
     * @param config the SMB configuration
     * @param pipeName the name of the pipe to call
     * @param data the data buffer to write to the pipe
     * @param off the offset in the data buffer
     * @param len the length of data to write
     */
    public TransCallNamedPipe(final Configuration config, final String pipeName, final byte[] data, final int off, final int len) {

     *
     * @param config the configuration to use
     * @param fid the file ID of the named pipe
     * @param data the data buffer to send
     * @param off the offset in the data buffer
     * @param len the length of data to send
     */
    public TransTransactNamedPipe(final Configuration config, final int fid, final byte[] data, final int off, final int len) {

            return this;
        }

        /**
         * Sets the search result offset.
         *
         * @param offset the number of results to skip
         * @return this builder for method chaining
         */
        public SearchConditionBuilder offset(final int offset) {
            this.offset = offset;
            return this;
        }

        /**

            final int length) throws CIFSException {
        final ArrayList<SID> list = new ArrayList<>(sids.length);
        int si;

        synchronized (this.sidCache) {
            for (si = 0; si < length; si++) {
                final SID s = sids[offset + si].unwrap(SID.class);
                final SID sid = this.sidCache.get(s);

    }

    /**
     * Decode a transform header from byte array
     *
     * @param buffer
     *            buffer to decode from
     * @param bufferIndex
     *            offset in buffer
     * @return new transform header instance
     */
    public static Smb2TransformHeader decode(final byte[] buffer, int bufferIndex) {
        final Smb2TransformHeader header = new Smb2TransformHeader();