}

    @Override
    protected int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = this.getSubCommand();
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        return 2;
    }

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

    @Override
    int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeParametersWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {

     * @return the current column number
     */
    int getColumnNumber();

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

	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgBatchJobPrefix(b *testing.B) {
	v := BatchJobPrefix{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgBatchJobPrefix(b *testing.B) {
	v := BatchJobPrefix{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])

	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsglocalLockMap(b *testing.B) {
	v := localLockMap{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsglocalLockMap(b *testing.B) {
	v := localLockMap{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])

    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override

type streamingBitrotWriter struct {
	iow          io.WriteCloser
	closeWithErr func(err error)
	h            hash.Hash
	shardSize    int64
	canClose     *sync.WaitGroup
	byteBuf      []byte
	finished     bool
}

func (b *streamingBitrotWriter) Write(p []byte) (int, error) {
	if len(p) == 0 {
		return 0, nil
	}
	if b.finished {
		return 0, errors.New("bitrot write not allowed")
	}
	if int64(len(p)) > b.shardSize {

    }

    /**
     * Add bytes sent
     *
     * @param bytes number of bytes
     */
    public void addBytesSent(long bytes) {
        bytesSent.addAndGet(bytes);
    }

    /**
     * Add bytes received
     *
     * @param bytes number of bytes
     */
    public void addBytesReceived(long bytes) {
        bytesReceived.addAndGet(bytes);
    }

    /**

     *
     * @see jcifs.internal.smb1.ServerMessageBlock#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#readParameterWordsWireFormat(byte[], int)
     */
    @Override

    /**
     * Set the serializer.
     * @param serializer the serializer function to convert raw data to byte array
     */
    public void setSerializer(final Function<Object, byte[]> serializer) {
        this.serializer = serializer;
    }

    /**
     * Get the data.
     * @return data
     */
    public byte[] getData() {
        if (data == null) {
            if (serializer == null || rawData == null) {