quite absurd for her to carry it further.

  So she set the little creature down, and felt quite relieved to
see it trot away quietly into the wood.  `If it had grown up,'
she said to herself, `it would have made a dreadfully ugly child:
but it makes rather a handsome pig, I think.'  And she began
thinking over other children she knew, who might do very well as
pigs, and was just saying to herself, `if one only knew the right

	sz := stat.Size()
	if sz <= metaDataReadDefault {
		buf = metaDataPoolGet()
		buf = buf[:sz]
	} else {
		buf = make([]byte, sz)
	}

	// Read file...
	_, err = io.ReadFull(f, buf)

	return buf, stat.ModTime().UTC(), osErrToFileErr(err)
}

// ReadAll is a raw call, reads content at any path and returns the buffer.

// Read reads data into p.
// It returns the number of bytes read into p.
// The bytes are taken from at most one Read on the underlying [Reader],
// hence n may be less than len(p).
// To read exactly len(p) bytes, use io.ReadFull(b, p).
// If the underlying [Reader] can return a non-zero count with io.EOF,
// then this Read method can do so as well; see the [io.Reader] docs.
func (b *Reader) Read(p []byte) (n int, err error) {
	n = len(p)

		err = rb.WriteByte(0)
		done <- err
		_, err = rb.TryWrite([]byte("world"))
		done <- err
		err = rb.TryWriteByte(0)
		done <- err
	}()

	buf := make([]byte, 100)
	n, err := io.ReadFull(rb, buf)
	if err != nil && err != io.ErrUnexpectedEOF {
		t.Fatalf("got: %q; want: %q", err, io.ErrUnexpectedEOF)
	}
	for writeErr := range done {
		if writeErr != ErrWriteOnClosed {

	if int64(len(p)) < unreadPartLen {
		n1, err = d.decrypter.Read(p)
		if err != nil {
			return 0, err
		}
		d.partDecRelOffset += int64(n1)
	} else {
		n1, err = io.ReadFull(d.decrypter, p[:unreadPartLen])
		if err != nil {
			return 0, err
		}

		// We should now proceed to next part, reset all
		// values appropriately.
		d.partEncRelOffset = 0
		d.partDecRelOffset = 0

	if err != nil {
		t.Fatal(err)
	}

	bucket := "bucket"
	object := "object"
	opts := ObjectOptions{}
	buf := make([]byte, smallFileThreshold*16)
	if _, err = io.ReadFull(crand.Reader, buf); err != nil {
		t.Fatal(err)
	}

	// Test use case 1: All disks are online, xl.meta are present, but data are missing

	}
	if err = xlStorage.MakeVol(t.Context(), volume); err != nil {
		t.Fatalf("Unable to create volume %s: %v", volume, err)
	}
	data := make([]byte, 8*1024)
	if _, err = io.ReadFull(rand.Reader, data); err != nil {
		t.Fatalf("Unable to create generate random data: %v", err)
	}
	if err = xlStorage.AppendFile(t.Context(), volume, object, data); err != nil {

r.(DefaultReader); ok { Read(b) return nil } fips140.RecordNonApproved() randutil.MaybeReadByte(r) _, err := io.ReadFull(r, b) return err } // ReadWithReaderDeterm is like ReadWithReader, but it doesn't call // [randutil.MaybeReadByte] on non-default Readers. func ReadWithReaderDeterm(r io.Reader, b []byte) error { if _, ok := r.(DefaultReader); ok { Read(b) return nil } fips140.RecordNonApproved() _, err := io.ReadFull(r, b) return err } golang.org/fips140@v1.0.0-c2097c7c/fips140/v1.0.0-c2097c7c/drbg/rand_test.go...

cryptographically secure random // bytes. It is intended for use in APIs that expose a rand io.Reader. func ReadWithReader(r io.Reader, b []byte) error { if _, ok := r.(DefaultReader); ok { Read(b) return nil } fips140.RecordNonApproved() _, err := io.ReadFull(r, b) return err } golang.org/fips140@v1.1.0-rc1/fips140/v1.1.0-rc1/drbg/rand_test.go // Copyright 2025 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package...

pkg io, func NewSectionReader(ReaderAt, int64, int64) *SectionReader
pkg io, func Pipe() (*PipeReader, *PipeWriter)
pkg io, func ReadAtLeast(Reader, []uint8, int) (int, error)
pkg io, func ReadFull(Reader, []uint8) (int, error)
pkg io, func TeeReader(Reader, Writer) Reader
pkg io, func WriteString(Writer, string) (int, error)
pkg io, method (*LimitedReader) Read([]uint8) (int, error)