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

    @Override
    int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        length = readInt4(buffer, bufferIndex);
        return 4;
    }

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

            assertEquals(0, smbComTreeDisconnect.readBytesWireFormat(buffer, i));
        }
    }

    /**
     * Test boundary conditions for buffer indices
     */
    @Test
    @DisplayName("Test boundary conditions for buffer indices")
    public void testBoundaryConditions() {
        // Given
        smbComTreeDisconnect = new SmbComTreeDisconnect(config);
        byte[] buffer = new byte[100];

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

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

    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        if (wordCount == 0) {
            return 0;
        }
        fileAttributes = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        lastWriteTime = readUTime(buffer, bufferIndex);
        bufferIndex += 4;
        fileSize = readInt4(buffer, bufferIndex);
        return 20;
    }

    @Override

        // Encode first
        byte[] buffer = new byte[256];
        int encodedSize = context.encode(buffer, 0);

        // Create new context for decoding
        CompressionNegotiateContext decodedContext = new CompressionNegotiateContext();
        int decodedSize = decodedContext.decode(buffer, 0, encodedSize);

        assertEquals(encodedSize, decodedSize);

                        throw new NdrException(NdrException.INVALID_CONFORMANCE);
                    }
                    this.buffer = new short[_buffers];
                }
                _src = _src.derive(_bufferi);
                for (int _i = 0; _i < _bufferl; _i++) {
                    this.buffer[_i] = (short) _src.dec_ndr_short();
                }
            }
        }
    }

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.createTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastAccessTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastWriteTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.alloc = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        this.free = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        this.sectPerAlloc = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

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

        // Read total allocation units.
        this.alloc = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // read caller available allocation units
        this.free = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;