reader.go

Documentation: testing/iotest

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  // Package iotest implements Readers and Writers useful mainly for testing.
		 6  package iotest
		 7  
		 8  import (
		 9  	"bytes"
		10  	"errors"
		11  	"fmt"
		12  	"io"
		13  )
		14  
		15  // OneByteReader returns a Reader that implements
		16  // each non-empty Read by reading one byte from r.
		17  func OneByteReader(r io.Reader) io.Reader { return &oneByteReader{r} }
		18  
		19  type oneByteReader struct {
		20  	r io.Reader
		21  }
		22  
		23  func (r *oneByteReader) Read(p []byte) (int, error) {
		24  	if len(p) == 0 {
		25  		return 0, nil
		26  	}
		27  	return r.r.Read(p[0:1])
		28  }
		29  
		30  // HalfReader returns a Reader that implements Read
		31  // by reading half as many requested bytes from r.
		32  func HalfReader(r io.Reader) io.Reader { return &halfReader{r} }
		33  
		34  type halfReader struct {
		35  	r io.Reader
		36  }
		37  
		38  func (r *halfReader) Read(p []byte) (int, error) {
		39  	return r.r.Read(p[0 : (len(p)+1)/2])
		40  }
		41  
		42  // DataErrReader changes the way errors are handled by a Reader. Normally, a
		43  // Reader returns an error (typically EOF) from the first Read call after the
		44  // last piece of data is read. DataErrReader wraps a Reader and changes its
		45  // behavior so the final error is returned along with the final data, instead
		46  // of in the first call after the final data.
		47  func DataErrReader(r io.Reader) io.Reader { return &dataErrReader{r, nil, make([]byte, 1024)} }
		48  
		49  type dataErrReader struct {
		50  	r			io.Reader
		51  	unread []byte
		52  	data	 []byte
		53  }
		54  
		55  func (r *dataErrReader) Read(p []byte) (n int, err error) {
		56  	// loop because first call needs two reads:
		57  	// one to get data and a second to look for an error.
		58  	for {
		59  		if len(r.unread) == 0 {
		60  			n1, err1 := r.r.Read(r.data)
		61  			r.unread = r.data[0:n1]
		62  			err = err1
		63  		}
		64  		if n > 0 || err != nil {
		65  			break
		66  		}
		67  		n = copy(p, r.unread)
		68  		r.unread = r.unread[n:]
		69  	}
		70  	return
		71  }
		72  
		73  // ErrTimeout is a fake timeout error.
		74  var ErrTimeout = errors.New("timeout")
		75  
		76  // TimeoutReader returns ErrTimeout on the second read
		77  // with no data. Subsequent calls to read succeed.
		78  func TimeoutReader(r io.Reader) io.Reader { return &timeoutReader{r, 0} }
		79  
		80  type timeoutReader struct {
		81  	r		 io.Reader
		82  	count int
		83  }
		84  
		85  func (r *timeoutReader) Read(p []byte) (int, error) {
		86  	r.count++
		87  	if r.count == 2 {
		88  		return 0, ErrTimeout
		89  	}
		90  	return r.r.Read(p)
		91  }
		92  
		93  // ErrReader returns an io.Reader that returns 0, err from all Read calls.
		94  func ErrReader(err error) io.Reader {
		95  	return &errReader{err: err}
		96  }
		97  
		98  type errReader struct {
		99  	err error
	 100  }
	 101  
	 102  func (r *errReader) Read(p []byte) (int, error) {
	 103  	return 0, r.err
	 104  }
	 105  
	 106  type smallByteReader struct {
	 107  	r	 io.Reader
	 108  	off int
	 109  	n	 int
	 110  }
	 111  
	 112  func (r *smallByteReader) Read(p []byte) (int, error) {
	 113  	if len(p) == 0 {
	 114  		return 0, nil
	 115  	}
	 116  	r.n = r.n%3 + 1
	 117  	n := r.n
	 118  	if n > len(p) {
	 119  		n = len(p)
	 120  	}
	 121  	n, err := r.r.Read(p[0:n])
	 122  	if err != nil && err != io.EOF {
	 123  		err = fmt.Errorf("Read(%d bytes at offset %d): %v", n, r.off, err)
	 124  	}
	 125  	r.off += n
	 126  	return n, err
	 127  }
	 128  
	 129  // TestReader tests that reading from r returns the expected file content.
	 130  // It does reads of different sizes, until EOF.
	 131  // If r implements io.ReaderAt or io.Seeker, TestReader also checks
	 132  // that those operations behave as they should.
	 133  //
	 134  // If TestReader finds any misbehaviors, it returns an error reporting them.
	 135  // The error text may span multiple lines.
	 136  func TestReader(r io.Reader, content []byte) error {
	 137  	if len(content) > 0 {
	 138  		n, err := r.Read(nil)
	 139  		if n != 0 || err != nil {
	 140  			return fmt.Errorf("Read(0) = %d, %v, want 0, nil", n, err)
	 141  		}
	 142  	}
	 143  
	 144  	data, err := io.ReadAll(&smallByteReader{r: r})
	 145  	if err != nil {
	 146  		return err
	 147  	}
	 148  	if !bytes.Equal(data, content) {
	 149  		return fmt.Errorf("ReadAll(small amounts) = %q\n\twant %q", data, content)
	 150  	}
	 151  	n, err := r.Read(make([]byte, 10))
	 152  	if n != 0 || err != io.EOF {
	 153  		return fmt.Errorf("Read(10) at EOF = %v, %v, want 0, EOF", n, err)
	 154  	}
	 155  
	 156  	if r, ok := r.(io.ReadSeeker); ok {
	 157  		// Seek(0, 1) should report the current file position (EOF).
	 158  		if off, err := r.Seek(0, 1); off != int64(len(content)) || err != nil {
	 159  			return fmt.Errorf("Seek(0, 1) from EOF = %d, %v, want %d, nil", off, err, len(content))
	 160  		}
	 161  
	 162  		// Seek backward partway through file, in two steps.
	 163  		// If middle == 0, len(content) == 0, can't use the -1 and +1 seeks.
	 164  		middle := len(content) - len(content)/3
	 165  		if middle > 0 {
	 166  			if off, err := r.Seek(-1, 1); off != int64(len(content)-1) || err != nil {
	 167  				return fmt.Errorf("Seek(-1, 1) from EOF = %d, %v, want %d, nil", -off, err, len(content)-1)
	 168  			}
	 169  			if off, err := r.Seek(int64(-len(content)/3), 1); off != int64(middle-1) || err != nil {
	 170  				return fmt.Errorf("Seek(%d, 1) from %d = %d, %v, want %d, nil", -len(content)/3, len(content)-1, off, err, middle-1)
	 171  			}
	 172  			if off, err := r.Seek(+1, 1); off != int64(middle) || err != nil {
	 173  				return fmt.Errorf("Seek(+1, 1) from %d = %d, %v, want %d, nil", middle-1, off, err, middle)
	 174  			}
	 175  		}
	 176  
	 177  		// Seek(0, 1) should report the current file position (middle).
	 178  		if off, err := r.Seek(0, 1); off != int64(middle) || err != nil {
	 179  			return fmt.Errorf("Seek(0, 1) from %d = %d, %v, want %d, nil", middle, off, err, middle)
	 180  		}
	 181  
	 182  		// Reading forward should return the last part of the file.
	 183  		data, err := io.ReadAll(&smallByteReader{r: r})
	 184  		if err != nil {
	 185  			return fmt.Errorf("ReadAll from offset %d: %v", middle, err)
	 186  		}
	 187  		if !bytes.Equal(data, content[middle:]) {
	 188  			return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle, data, content[middle:])
	 189  		}
	 190  
	 191  		// Seek relative to end of file, but start elsewhere.
	 192  		if off, err := r.Seek(int64(middle/2), 0); off != int64(middle/2) || err != nil {
	 193  			return fmt.Errorf("Seek(%d, 0) from EOF = %d, %v, want %d, nil", middle/2, off, err, middle/2)
	 194  		}
	 195  		if off, err := r.Seek(int64(-len(content)/3), 2); off != int64(middle) || err != nil {
	 196  			return fmt.Errorf("Seek(%d, 2) from %d = %d, %v, want %d, nil", -len(content)/3, middle/2, off, err, middle)
	 197  		}
	 198  
	 199  		// Reading forward should return the last part of the file (again).
	 200  		data, err = io.ReadAll(&smallByteReader{r: r})
	 201  		if err != nil {
	 202  			return fmt.Errorf("ReadAll from offset %d: %v", middle, err)
	 203  		}
	 204  		if !bytes.Equal(data, content[middle:]) {
	 205  			return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle, data, content[middle:])
	 206  		}
	 207  
	 208  		// Absolute seek & read forward.
	 209  		if off, err := r.Seek(int64(middle/2), 0); off != int64(middle/2) || err != nil {
	 210  			return fmt.Errorf("Seek(%d, 0) from EOF = %d, %v, want %d, nil", middle/2, off, err, middle/2)
	 211  		}
	 212  		data, err = io.ReadAll(r)
	 213  		if err != nil {
	 214  			return fmt.Errorf("ReadAll from offset %d: %v", middle/2, err)
	 215  		}
	 216  		if !bytes.Equal(data, content[middle/2:]) {
	 217  			return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle/2, data, content[middle/2:])
	 218  		}
	 219  	}
	 220  
	 221  	if r, ok := r.(io.ReaderAt); ok {
	 222  		data := make([]byte, len(content), len(content)+1)
	 223  		for i := range data {
	 224  			data[i] = 0xfe
	 225  		}
	 226  		n, err := r.ReadAt(data, 0)
	 227  		if n != len(data) || err != nil && err != io.EOF {
	 228  			return fmt.Errorf("ReadAt(%d, 0) = %v, %v, want %d, nil or EOF", len(data), n, err, len(data))
	 229  		}
	 230  		if !bytes.Equal(data, content) {
	 231  			return fmt.Errorf("ReadAt(%d, 0) = %q\n\twant %q", len(data), data, content)
	 232  		}
	 233  
	 234  		n, err = r.ReadAt(data[:1], int64(len(data)))
	 235  		if n != 0 || err != io.EOF {
	 236  			return fmt.Errorf("ReadAt(1, %d) = %v, %v, want 0, EOF", len(data), n, err)
	 237  		}
	 238  
	 239  		for i := range data {
	 240  			data[i] = 0xfe
	 241  		}
	 242  		n, err = r.ReadAt(data[:cap(data)], 0)
	 243  		if n != len(data) || err != io.EOF {
	 244  			return fmt.Errorf("ReadAt(%d, 0) = %v, %v, want %d, EOF", cap(data), n, err, len(data))
	 245  		}
	 246  		if !bytes.Equal(data, content) {
	 247  			return fmt.Errorf("ReadAt(%d, 0) = %q\n\twant %q", len(data), data, content)
	 248  		}
	 249  
	 250  		for i := range data {
	 251  			data[i] = 0xfe
	 252  		}
	 253  		for i := range data {
	 254  			n, err = r.ReadAt(data[i:i+1], int64(i))
	 255  			if n != 1 || err != nil && (i != len(data)-1 || err != io.EOF) {
	 256  				want := "nil"
	 257  				if i == len(data)-1 {
	 258  					want = "nil or EOF"
	 259  				}
	 260  				return fmt.Errorf("ReadAt(1, %d) = %v, %v, want 1, %s", i, n, err, want)
	 261  			}
	 262  			if data[i] != content[i] {
	 263  				return fmt.Errorf("ReadAt(1, %d) = %q want %q", i, data[i:i+1], content[i:i+1])
	 264  			}
	 265  		}
	 266  	}
	 267  	return nil
	 268  }
	 269
View as plain text