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

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

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

        bufferIndex += 8;
        this.lastWriteTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.changeTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.endOfFile = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);

	v := PoolDecommissionInfo{}
	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 BenchmarkDecodePoolDecommissionInfo(b *testing.B) {
	v := PoolDecommissionInfo{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

	v := BatchJobKV{}
	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 BenchmarkDecodeBatchJobKV(b *testing.B) {
	v := BatchJobKV{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

	v := BatchJobKeyRotateEncryption{}
	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 BenchmarkDecodeBatchJobKeyRotateEncryption(b *testing.B) {
	v := BatchJobKeyRotateEncryption{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	v := xlMetaDataDirDecoder{}
	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 BenchmarkDecodexlMetaDataDirDecoder(b *testing.B) {
	v := xlMetaDataDirDecoder{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

        }
        SMBUtil.writeInt4(flags, buffer, offset);
        offset += 4;

        // NotificationFilter (4 bytes)
        SMBUtil.writeInt4(notificationFilter, buffer, offset);
        offset += 4;

        return offset - start;
    }

    /**
     * Decode directory lease context from buffer
     *
     * @param buffer the buffer containing the context data

     *
     * @param buffer source buffer
     * @param bufferIndex starting index
     * @return decoded transform
     */
    public static Smb2RdmaTransform decode(byte[] buffer, int bufferIndex) {
        long offset = SMBUtil.readInt8(buffer, bufferIndex);
        int token = SMBUtil.readInt4(buffer, bufferIndex + 8);
        int length = SMBUtil.readInt4(buffer, bufferIndex + 12);

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

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

                new TestNetbiosName("WORKSTATION1", 0x00, "CORP.LOCAL"));

        // Write to buffer
        byte[] buffer = new byte[512];
        int written = originalPacket.writeWireFormat(buffer, 0);

        // Read from buffer
        ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
        SessionRequestPacket readPacket = new SessionRequestPacket(mockConfig);