func (r *Reader) uint32At(off uint32) uint32 {
	b := r.BytesAt(off, 4)
	return binary.LittleEndian.Uint32(b)
}

func (r *Reader) int32At(off uint32) int32 {
	return int32(r.uint32At(off))
}

func (r *Reader) uint16At(off uint32) uint16 {
	b := r.BytesAt(off, 2)
	return binary.LittleEndian.Uint16(b)
}

func (r *Reader) uint8At(off uint32) uint8 {
	b := r.BytesAt(off, 1)
	return b[0]
}

func (rb *reorderBuffer) runeAt(n int) rune {
	inf := rb.rune[n]
	r, _ := utf8.DecodeRune(rb.byte[inf.pos : inf.pos+inf.size])
	return r
}

// bytesAt returns the UTF-8 encoding of the rune at position n.
// It is used for Hangul and recomposition.
func (rb *reorderBuffer) bytesAt(n int) []byte {
	inf := rb.rune[n]
	return rb.byte[inf.pos : int(inf.pos)+int(inf.size)]
}

    byte[] encode(Closure<Encoder> closure) {
        def bytes = new ByteArrayOutputStream()
        encodeTo(bytes, closure)
        return bytes.toByteArray()
    }

    byte[] truncate(Closure<Encoder> closure) {
        def bytes = new ByteArrayOutputStream()
        encodeTo(bytes, closure)
        def result = bytes.toByteArray()
        if (result.length < 2) {
            return [] as byte[]

        def text1 = "some text"
        def bytes1 = text1.bytes
        def text2 = "more"
        def bytes2 = text2.bytes

        when:
        async {
            start {
                def buffer = new byte[1024]

                def nread = stream.read(buffer)
                assert nread == bytes1.length
                assert new String(buffer, 0, nread) == text1

	var buf1 bytes.Buffer
	_, err := Fprint(&buf1, ast1, LineForm)
	if err != nil {
		panic(err)
	}
	bytes1 := buf1.Bytes()

	ast2, err := Parse(NewFileBase(filename), &buf1, nil, nil, 0)
	if err != nil {
		panic(err)
	}

	var buf2 bytes.Buffer
	_, err = Fprint(&buf2, ast2, LineForm)
	if err != nil {
		panic(err)
	}
	bytes2 := buf2.Bytes()

/**
 * Static utility methods pertaining to {@code byte} primitives, that are not already found in
 * either {@link Byte} or {@link Arrays}, <i>and interpret bytes as neither signed nor unsigned</i>.
 * The methods which specifically treat bytes as signed or unsigned are found in {@link SignedBytes}
 * and {@link UnsignedBytes}.
 *
 * <p>See the Guava User Guide article on <a

/**
 * Static utility methods pertaining to {@code byte} primitives, that are not already found in
 * either {@link Byte} or {@link Arrays}, <i>and interpret bytes as neither signed nor unsigned</i>.
 * The methods which specifically treat bytes as signed or unsigned are found in {@link SignedBytes}
 * and {@link UnsignedBytes}.
 *
 * <p>See the Guava User Guide article on <a

	RttUs             uint32
	MinRttUs          uint32
	BytesInFlight     uint32
	Cwnd              uint32
	SndWnd            uint32
	RcvWnd            uint32
	RcvBuf            uint32
	BytesOut          uint64
	BytesIn           uint64
	BytesReordered    uint32
	BytesRetrans      uint32
	FastRetrans       uint32
	DupAcksIn         uint32
	TimeoutEpisodes   uint32
	SynRetrans        uint8

        given:
        def byteBuffer = createTestInstance()
        def input = byteBuffer.getInputStream()
        def bytesOut = new ByteArrayOutputStream(byteBuffer
                .totalBytesUnread())

        when:
        copy(input, bytesOut, 2048)

        then:
        bytesOut.toByteArray() == testbuffer
    }

    def "can use InputStream and OutputStream interfaces to access buffer"() {

! stderr 'path\\ttest/nopgo\\n.*build\\t-pgo='

# go test works the same way
go test -a -n -pgo=auto ./a ./b ./nopgo
stderr -count=1 'compile.*-pgoprofile=.*a(/|\\\\)a_test\.go'
stderr -count=1 'compile.*-pgoprofile=.*b(/|\\\\)b_test\.go'
stderr -count=2 'compile.*-pgoprofile=.*dep(/|\\\\)dep\.go'
! stderr 'compile.*-pgoprofile=.*nopgo(/|\\\\)nopgo_test\.go'

# test-only dependencies also have profiles attached