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

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

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

     */
    protected void write(final String text, final String contentType, final String encoding) {
        final StringBuilder buf = new StringBuilder(50);
        if (contentType == null) {
            buf.append("text/plain");
        } else {
            buf.append(contentType);
        }
        buf.append("; charset=");
        final String enc;
        if (encoding == null) {

		if o.prefixAll != "" {
			name = pathJoin(o.prefixAll, name)
		}

		// Do small files async
		n++
		if header.Size <= xioutil.MediumBlock {
			asyncWriters <- struct{}{}
			bufp := xioutil.ODirectPoolMedium.Get()
			b := (*bufp)[:header.Size]
			if _, err := io.ReadFull(tarReader, b); err != nil {
				return err
			}
			wg.Add(1)
			go func(name string, fi fs.FileInfo, b []byte) {

    assertEquals(4, numOfByteRead);

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

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

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

    assertEquals(4, numOfByteRead);

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

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

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

import (
	"archive/zip"
	"bytes"
	"compress/flate"
	"fmt"
	"io"
	"log"
	"os"
)

func ExampleWriter() {
	// Create a buffer to write our archive to.
	buf := new(bytes.Buffer)

	// Create a new zip archive.
	w := zip.NewWriter(buf)

	// Add some files to the archive.
	var files = []struct {
		Name, Body string
	}{
		{"readme.txt", "This archive contains some text files."},

	buf.WriteByte(13)
	buf.WriteString(":message-type")
	buf.WriteByte(7)
	buf.Write([]byte{0, 5})
	buf.WriteString("event")

	buf.WriteByte(13)
	buf.WriteString(":content-type")
	buf.WriteByte(7)
	buf.Write([]byte{0, 8})
	buf.WriteString("text/xml")

	buf.WriteByte(11)
	buf.WriteString(":event-type")
	buf.WriteByte(7)
	buf.Write([]byte{0, 5})
	buf.WriteString("Stats")

	fmt.Println(buf.Bytes())

        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);

  }

  public void testOpenStream() throws IOException {
    Reader reader = source.openStream();

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
    writer.close();

    assertExpectedString(writer.toString());
  }

        int off = 0;
        assertEquals(65535, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(65535, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(0, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(0x12345678, SMBUtil.readInt4(buf, off));
        off += 4;
        assertEquals(blob.length, SMBUtil.readInt2(buf, off));
    }