return 0;
    }

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

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

    @Override
    public String toString() {

func BenchmarkEncodeAccElem(b *testing.B) {
	v := AccElem{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeAccElem(b *testing.B) {
	v := AccElem{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

	v := BatchJobExpire{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeBatchJobExpire(b *testing.B) {
	v := BatchJobExpire{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

    /**
     * Constructs an SMB negotiation result.
     *
     * @param request the negotiation request
     * @param response the negotiation response
     * @param negoReqBuffer the raw request buffer
     * @param negoRespBuffer the raw response buffer
     *
     */
    public SmbNegotiation(final SmbNegotiationRequest request, final SmbNegotiationResponse response, final byte[] negoReqBuffer,
            final byte[] negoRespBuffer) {

    int slen = s.length();

    // Get a destination buffer and setup some loop variables.
    char[] dest = Platform.charBufferFromThreadLocal();
    int destSize = dest.length;
    int destIndex = 0;
    int lastEscape = 0;

    // Loop through the rest of the string, replacing when needed into the
    // destination buffer, which gets grown as needed as well.
    for (; index < slen; index++) {

        byte[] buffer = new byte[4];
        pdis.readFully(buffer);
        assertArrayEquals(data, buffer);
    }

    @Test
    public void testReadFullyWithOffset() throws IOException {
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        PacDataInputStream pdis = createInputStream(data);
        byte[] buffer = new byte[6];
        pdis.readFully(buffer, 1, 4);

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        supportSearchBits = (buffer[bufferIndex] & SMB_SUPPORT_SEARCH_BITS) == SMB_SUPPORT_SEARCH_BITS;
        shareIsInDfs = (buffer[bufferIndex] & SMB_SHARE_IS_IN_DFS) == SMB_SHARE_IS_IN_DFS;
        return 2;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        SMBUtil.writeInt2(dstIndex - getHeaderStart(), dst, nameOffsetOffset);

        System.arraycopy(nameBytes, 0, dst, dstIndex, nameBytes.length);
        if (nameBytes.length == 0) {
            // buffer must contain at least one byte
            dstIndex++;
        } else {
            dstIndex += nameBytes.length;
        }

        dstIndex += pad8(dstIndex);

     *
     * @param buffer buffer to read data into
     * @param remoteAddress remote memory address for RDMA read
     * @param remoteKey remote memory key
     * @param length number of bytes to read
     * @return number of bytes actually read
     * @throws IOException if read operation fails
     */

        this.creationTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastAccessTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastWriteTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.changeTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;