// Body starts at bufferIndex + 64
        // Structure size = 2
        SMBUtil.writeInt2(2, buffer, bufferIndex + 64);

        // Decode the response
        int result = response.decode(buffer, bufferIndex);

        assertEquals(66, result);
        assertEquals(0, response.getStatus()); // Should be STATUS_SUCCESS
    }

    @Test

          // otherwise try to presize a StringBuilder
          // it is kind of lame that we need to construct a decoder to access this value.
          // if this is a concern we could add special cases for some known charsets (like utf8)
          // or we could avoid inputstreamreader and use the decoder api directly
          // TODO(lukes): in a real implementation we would need to handle overflow conditions

     * @throws NdrException if encoding fails
     */
    public abstract void encode_in(NdrBuffer buf) throws NdrException;

    /**
     * Decode the output parameters from this DCERPC message.
     * @param buf the buffer to decode from
     * @throws NdrException if decoding fails
     */
    public abstract void decode_out(NdrBuffer buf) throws NdrException;

    }

    @Override
    public long getSize() {
        return 0L;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.createTime = SMBUtil.readTime(buffer, bufferIndex);

        // Test decode method
        byte[] buffer = new byte[512];
        int bufferIndex = 0;
        int expectedDecodeLength = 128;
        when(response.decode(buffer, bufferIndex)).thenReturn(expectedDecodeLength);
        assertEquals(expectedDecodeLength, response.decode(buffer, bufferIndex));

        // Test encode method

        @DisplayName("fromUNIBytes should decode UTF-16LE bytes to string")
        void testFromUNIBytes() {
            // Given
            byte[] bytes = TEST_STRING.getBytes(StandardCharsets.UTF_16LE);

            // When
            String result = Strings.fromUNIBytes(bytes, 0, bytes.length);

            // Then
            assertEquals(TEST_STRING, result, "Should decode back to original string");
        }

     * @return the resumeKey
     */
    public byte[] getResumeKey() {
        return this.resumeKey;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        if (len < 24) {

	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecoderebalanceInfo Msgsize() is inaccurate")
	}

	vn := rebalanceInfo{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

    public long getFree() {
        return this.free * this.sectPerAlloc * this.bytesPerSect;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        bufferIndex += 4; // skip idFileSystem

    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += UnsignedLongs.decode(decimalStrings[j]);
    }
    return tmp;
  }

  @Benchmark
  long parseDecode16(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += UnsignedLongs.decode(prefixedHexStrings[j]);
    }
    return tmp;
  }

  @Benchmark