tillOffset int64           // Affects the length of data requested in disk.ReadFile depending on Read()'s offset
	buf        []byte          // Holds bit-rot verified data
}

func (b *wholeBitrotReader) ReadAt(buf []byte, offset int64) (n int, err error) {
	if b.buf == nil {
		b.buf = make([]byte, b.tillOffset-offset)
		if _, err := b.disk.ReadFile(context.TODO(), b.volume, b.filePath, offset, b.buf, b.verifier); err != nil {

                fun String.invoke(some: Int) {}
                operator fun Long.invoke(some: Int) {}

                fun Float.invoke(some: Int) {}
                infix fun Byte.invoke(some: Int) {}

                interface Source {
                    infix fun String.plus(some: List<Int>): String
                    operator fun Int.plus(some: List<Int>): Int
                }
            """,

    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        SMBUtil.writeInt2(this.searchAttributes, dst, dstIndex);
        return 2;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x04;
        dstIndex++;

    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        int start = bufferIndex;

        if (len < 32) {
            throw new SMBProtocolDecodingException("Lease V1 context data too short: " + len);
        }

        // Read lease V1 data (32 bytes)
        byte[] keyBytes = new byte[16];
        System.arraycopy(buffer, bufferIndex, keyBytes, 0, 16);

     * Default constructor for ValidateNegotiateInfoResponse
     */
    public ValidateNegotiateInfoResponse() {
        // Default constructor
    }

    private int capabilities;
    private final byte[] serverGuid = new byte[16];
    private int securityMode;
    private int dialect;

    /**
     * Gets the server capabilities
     *
     * @return the capabilities flags from the server
     */

    int writeBodyWireFormat(final byte[] dst, final int dstIndex) {
        final int tmp = this.questionName.hexCode;
        this.questionName.hexCode = 0x00; // type has to be 0x00 for node status
        final int result = writeQuestionSectionWireFormat(dst, dstIndex);
        this.questionName.hexCode = tmp;
        return result;
    }

    @Override
    int readBodyWireFormat(final byte[] src, final int srcIndex) {

    }

    @Override
    public byte[] getSessionKey() throws CIFSException {
        return this.handle.getSessionKey();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.dcerpc.DcerpcHandle#doSendReceiveFragment(byte[], int, int, byte[])
     */
    @Override
    protected int doSendReceiveFragment(final byte[] buf, final int off, final int length, final byte[] inB) throws IOException {

        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SSPContext#verifyMIC(byte[], byte[])
     */
    @Override
    public void verifyMIC(byte[] data, byte[] mic) throws CIFSException {
        try {
            this.gssContext.verifyMIC(mic, 0, mic.length, data, 0, data.length, new MessageProp(false));
        } catch (GSSException e) {

import java.util.Arrays;

public class Smb2LeaseKey {
    private final byte[] key;  // 16-byte lease key
    private static final SecureRandom random = new SecureRandom();
    
    public Smb2LeaseKey() {
        this.key = new byte[16];
        random.nextBytes(this.key);
    }
    
    public Smb2LeaseKey(byte[] key) {
        if (key.length != 16) {

func TestSplitError(t *testing.T) {
	// Create a split function that delivers a little data, then a predictable error.
	numSplits := 0
	const okCount = 7
	errorSplit := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
		if atEOF {
			panic("didn't get enough data")
		}
		if numSplits >= okCount {
			return 0, nil, testError
		}
		numSplits++
		return 1, data[0:1], nil
	}