synchronized (this.cache) {
            byte[] buf;

            if (this.freeBuffers > 0) {
                for (int i = 0; i < this.cache.length; i++) {
                    if (this.cache[i] != null) {
                        buf = (byte[]) this.cache[i];
                        this.cache[i] = null;
                        this.freeBuffers--;
                        return buf;
                    }
                }

            buf.enc_ndr_long(charCount + 1); // MaximumCount (including null terminator)
            buf.enc_ndr_long(0); // Offset
            buf.enc_ndr_long(charCount + 1); // ActualCount (including null terminator)

            // String data in UTF-16LE
            buf.writeOctetArray(wideBytes, 0, wideBytes.length);
            buf.enc_ndr_short(0); // Wide null terminator

	hdrVer, buf, e := msgp.ReadUintBytes(buf)
	if e != nil {
		return 0, buf, e
	}
	metaVer, buf, e := msgp.ReadUintBytes(buf)
	if e != nil {
		return 0, buf, e
	}
	if hdrVer > xlHeaderVersion {
		return 0, buf, fmt.Errorf("decodeXLHeaders: Unknown xl header version %d", metaVer)
	}
	if metaVer > xlMetaVersion {
		return 0, buf, fmt.Errorf("decodeXLHeaders: Unknown xl meta version %d", metaVer)
	}

        int maxCount = buf.dec_ndr_long();
        int offset = buf.dec_ndr_long();
        int actualCount = buf.dec_ndr_long();

        if (actualCount <= 0) {
            return "";
        }

        // Read wide string data (UTF-16LE)
        int byteCount = (actualCount - 1) * 2; // Exclude null terminator
        byte[] wideBytes = new byte[byteCount];
        buf.readOctetArray(wideBytes, 0, byteCount);

            final StringBuilder buf = new StringBuilder(100);
            if (strings.length > 1) {
                for (int i = 0; i < strings.length - 1; i++) {
                    if (buf.length() != 0) {
                        buf.append('.');
                    }
                    buf.append(strings[i]);
                }
                filePrefix = buf.toString();

    assertEquals(4, numOfByteRead);

    assertEquals(expectedHash, in.hash());
  }

  public void testHash_hashesCorrectlyReadOutOfBound() throws Exception {
    HashCode expectedHash = Hashing.md5().hashBytes(testBytes);
    HashingInputStream in = new HashingInputStream(Hashing.md5(), buffer);

    byte[] buf = new byte[100];
    int numOfByteRead = in.read(buf, 0, buf.length);

     */
    public String getPathPrefix() {
        final StringBuilder buf = new StringBuilder(100);
        buf.append("smb1://");
        if (server != null) {
            buf.append(server);
            if (port > 0) {
                buf.append(':');
                buf.append(port);
            }
            buf.append('/');
        }
        return buf.toString();
    }

    /**

        if (buf.length < i + NAME_LEN_SIZE) {
            throw new IllegalArgumentException();
        }
        len = 0xff000000 & buf[i++] << 24;
        len |= 0x00ff0000 & buf[i++] << 16;
        len |= 0x0000ff00 & buf[i++] << 8;
        len |= 0x000000ff & buf[i++];

        // NAME
        if (buf.length < i + len) {
            throw new IllegalArgumentException();
        }
        this.name = new String(buf, i, len);

        }

        int off = this.handle.recv(buf, 0, buf.length);
        if (buf[0] != 5 || buf[1] != 0) {
            throw new IOException("Unexpected DCERPC PDU header");
        }

        final int length = Encdec.dec_uint16le(buf, 8);
        if (length > getMaxRecv()) {
            throw new IOException("Unexpected fragment length: " + length);
        }

        while (off < length) {

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

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

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