return st.String()
}

type Reader interface {
	Read() ([]byte, error)
}

// YAMLReader adapts from Kubernetes YAMLReader(apimachinery.k8s.io/pkg/util/yaml/decoder.go).
// It records the start line number of the chunk it reads each time.
type YAMLReader struct {
	reader   Reader
	currLine int
}

func NewYAMLReader(r *bufio.Reader) *YAMLReader {
	return &YAMLReader{
		reader:   &LineReader{reader: r},
		currLine: 0,

        then:
        poll(60) {
            assert readLog(executer.daemonBaseDir).contains("taking a nap...")
        }

        when:
        executer.withArguments("--stop").run()

        then:
        sleeper.waitForFailure()

        poll(5, 1) {
            def log = readLog(executer.daemonBaseDir)
            assert log.contains(DaemonMessages.REMOVING_PRESENCE_DUE_TO_STOP)

func init() {
	Reader = &reader{}
	batchedGetRandom = batched(getRandom, maxGetRandomRead)
}

var jsCrypto = js.Global().Get("crypto")
var uint8Array = js.Global().Get("Uint8Array")

// reader implements a pseudorandom generator
// using JavaScript crypto.getRandomValues method.
// See https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues.
type reader struct{}

env GOPROXY=$proxy/403,$proxy
! go get rsc.io/quote@v1.2.0
stderr 'reading.*/403/rsc.io/.*: 403 Forbidden'

# get should not walk past non-4xx errors if proxies are separated with ','.
env GOPROXY=$proxy/500,$proxy
! go get rsc.io/quote@v1.3.0
stderr 'reading.*/500/rsc.io/.*: 500 Internal Server Error'

# get should walk past other 4xx errors if proxies are separated with '|'.

    }

    @Nonnull
    default T read(@Nonnull Reader reader) throws XmlReaderException {
        return read(reader, true);
    }

    @Nonnull
    default T read(@Nonnull Reader reader, boolean strict) throws XmlReaderException {
        return read(XmlReaderRequest.builder().reader(reader).strict(strict).build());
    }

    @Nonnull

	if !e.failure && err != nil {
		return fmt.Errorf("unexpected error while reading the trace: %v", err)
	}
	if e.failure && err == nil {
		return fmt.Errorf("expected error while reading the trace: want something matching %q, got none", e.errorMatcher)
	}
	if e.failure && err != nil && !e.errorMatcher.MatchString(err.Error()) {
		return fmt.Errorf("unexpected error while reading the trace: want something matching %q, got %s", e.errorMatcher, err.Error())
	}

        }
    }

    @Override
    public org.apache.maven.model.Model read(Reader reader, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(reader, "reader cannot be null");
        try (Reader r = reader) {
            org.apache.maven.api.model.Model model = read(null, null, r, options);
            return new org.apache.maven.model.Model(model);

    }

    /**
     * Method read.
     *
     * @param reader a reader object.
     * @param strict a strict object.
     * @return Metadata
     * @throws IOException            IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     *                                any.
     */
    public Metadata read(Reader reader, boolean strict) throws IOException, XmlPullParserException {
        try {

	"log" // for Fatal
	"math"

	"fmt" // for Printf

	"math"

	"log" // for Fatal

	"errors"

	"io" // for Reader
)

import (
	"fmt" // for Printf

	"errors"
	"io"  // for Reader
	"log" // for Fatal
	"math"

	"errors"
	"fmt" // for Printf
	"io"  // for Reader
	"log" // for Fatal
	"math"
)

// Test deduping and extended sorting
import (

        private final RandomAccessFile file;
        private final Reader<T> reader;
        private final KryoBackedDecoder decoder;

        public Source(File file, Reader<T> reader) throws FileNotFoundException {
            this.file = new RandomAccessFile(file, "r");
            this.reader = reader;
            this.decoder = new KryoBackedDecoder(new BlockInputStream(this.file, 0));
        }