v := localLockMap{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

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

	vn := localLockMap{}
	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 fun <init> (Ljava/security/KeyPair;Ljava/security/cert/X509Certificate;)V
	public final fun certificate ()Ljava/security/cert/X509Certificate;
	public final fun certificatePem ()Ljava/lang/String;
	public static final fun decode (Ljava/lang/String;)Lokhttp3/tls/HeldCertificate;
	public final fun keyPair ()Ljava/security/KeyPair;
	public final fun privateKeyPkcs1Pem ()Ljava/lang/String;
	public final fun privateKeyPkcs8Pem ()Ljava/lang/String;
}

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


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

	v := BaseOptions{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

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

	vn := BaseOptions{}
	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)
	}

     * @param len
     * @throws IOException
     */
    public FileNotifyInformationImpl ( byte[] buffer, int bufferIndex, int len ) throws IOException {
        decode(buffer, bufferIndex, len);
    }


    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {
        if (len == 0) {
        	// nothing to do
        	return 0;
        }

                    final String key = urlCodec.decode(pair.substring(0, pos), enc);
                    List<String> list = paramListMap.get(key);
                    if (list == null) {
                        list = new ArrayList<>();
                        paramListMap.put(key, list);
                    }
                    if (pos + 1 < pair.length()) {
                        list.add(urlCodec.decode(pair.substring(pos + 1), enc));

	v := ActiveWorkerStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

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

	vn := ActiveWorkerStat{}
	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)

            this.unlocks[ i ] = createLockRange();
            bufferIndex += this.unlocks[ i ].decode(buffer, bufferIndex, buffer.length);
        }

        for ( int i = 0; i < this.locks.length; i++ ) {
            this.locks[ i ] = createLockRange();
            bufferIndex += this.locks[ i ].decode(buffer, bufferIndex, buffer.length);
        }

        return start - bufferIndex;
    }

	v := BucketReplicationResyncStatus{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

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

	vn := BucketReplicationResyncStatus{}
	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 {

    assertThat(encoding.encode(decoded.getBytes(UTF_8), offset, len)).isEqualTo(encoded);
  }

  private static void testDecodes(BaseEncoding encoding, String encoded, String decoded) {
    assertThat(encoding.canDecode(encoded)).isTrue();
    assertThat(encoding.decode(encoded)).isEqualTo(decoded.getBytes(UTF_8));
  }