reader_test.go

Documentation: testing/iotest

		 1  // Copyright 2019 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
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"errors"
		10  	"io"
		11  	"strings"
		12  	"testing"
		13  )
		14  
		15  func TestOneByteReader_nonEmptyReader(t *testing.T) {
		16  	msg := "Hello, World!"
		17  	buf := new(bytes.Buffer)
		18  	buf.WriteString(msg)
		19  
		20  	obr := OneByteReader(buf)
		21  	var b []byte
		22  	n, err := obr.Read(b)
		23  	if err != nil || n != 0 {
		24  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
		25  	}
		26  
		27  	b = make([]byte, 3)
		28  	// Read from obr until EOF.
		29  	got := new(bytes.Buffer)
		30  	for i := 0; ; i++ {
		31  		n, err = obr.Read(b)
		32  		if err != nil {
		33  			break
		34  		}
		35  		if g, w := n, 1; g != w {
		36  			t.Errorf("Iteration #%d read %d bytes, want %d", i, g, w)
		37  		}
		38  		got.Write(b[:n])
		39  	}
		40  	if g, w := err, io.EOF; g != w {
		41  		t.Errorf("Unexpected error after reading all bytes\n\tGot:	%v\n\tWant: %v", g, w)
		42  	}
		43  	if g, w := got.String(), "Hello, World!"; g != w {
		44  		t.Errorf("Read mismatch\n\tGot:	%q\n\tWant: %q", g, w)
		45  	}
		46  }
		47  
		48  func TestOneByteReader_emptyReader(t *testing.T) {
		49  	r := new(bytes.Buffer)
		50  
		51  	obr := OneByteReader(r)
		52  	var b []byte
		53  	if n, err := obr.Read(b); err != nil || n != 0 {
		54  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
		55  	}
		56  
		57  	b = make([]byte, 5)
		58  	n, err := obr.Read(b)
		59  	if g, w := err, io.EOF; g != w {
		60  		t.Errorf("Error mismatch\n\tGot:	%v\n\tWant: %v", g, w)
		61  	}
		62  	if g, w := n, 0; g != w {
		63  		t.Errorf("Unexpectedly read %d bytes, wanted %d", g, w)
		64  	}
		65  }
		66  
		67  func TestHalfReader_nonEmptyReader(t *testing.T) {
		68  	msg := "Hello, World!"
		69  	buf := new(bytes.Buffer)
		70  	buf.WriteString(msg)
		71  	// empty read buffer
		72  	hr := HalfReader(buf)
		73  	var b []byte
		74  	n, err := hr.Read(b)
		75  	if err != nil || n != 0 {
		76  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
		77  	}
		78  	// non empty read buffer
		79  	b = make([]byte, 2)
		80  	got := new(bytes.Buffer)
		81  	for i := 0; ; i++ {
		82  		n, err = hr.Read(b)
		83  		if err != nil {
		84  			break
		85  		}
		86  		if g, w := n, 1; g != w {
		87  			t.Errorf("Iteration #%d read %d bytes, want %d", i, g, w)
		88  		}
		89  		got.Write(b[:n])
		90  	}
		91  	if g, w := err, io.EOF; g != w {
		92  		t.Errorf("Unexpected error after reading all bytes\n\tGot:	%v\n\tWant: %v", g, w)
		93  	}
		94  	if g, w := got.String(), "Hello, World!"; g != w {
		95  		t.Errorf("Read mismatch\n\tGot:	%q\n\tWant: %q", g, w)
		96  	}
		97  }
		98  
		99  func TestHalfReader_emptyReader(t *testing.T) {
	 100  	r := new(bytes.Buffer)
	 101  
	 102  	hr := HalfReader(r)
	 103  	var b []byte
	 104  	if n, err := hr.Read(b); err != nil || n != 0 {
	 105  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
	 106  	}
	 107  
	 108  	b = make([]byte, 5)
	 109  	n, err := hr.Read(b)
	 110  	if g, w := err, io.EOF; g != w {
	 111  		t.Errorf("Error mismatch\n\tGot:	%v\n\tWant: %v", g, w)
	 112  	}
	 113  	if g, w := n, 0; g != w {
	 114  		t.Errorf("Unexpectedly read %d bytes, wanted %d", g, w)
	 115  	}
	 116  }
	 117  
	 118  func TestTimeOutReader_nonEmptyReader(t *testing.T) {
	 119  	msg := "Hello, World!"
	 120  	buf := new(bytes.Buffer)
	 121  	buf.WriteString(msg)
	 122  	// empty read buffer
	 123  	tor := TimeoutReader(buf)
	 124  	var b []byte
	 125  	n, err := tor.Read(b)
	 126  	if err != nil || n != 0 {
	 127  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
	 128  	}
	 129  	// Second call should timeout
	 130  	n, err = tor.Read(b)
	 131  	if g, w := err, ErrTimeout; g != w {
	 132  		t.Errorf("Error mismatch\n\tGot:	%v\n\tWant: %v", g, w)
	 133  	}
	 134  	if g, w := n, 0; g != w {
	 135  		t.Errorf("Unexpectedly read %d bytes, wanted %d", g, w)
	 136  	}
	 137  	// non empty read buffer
	 138  	tor2 := TimeoutReader(buf)
	 139  	b = make([]byte, 3)
	 140  	if n, err := tor2.Read(b); err != nil || n == 0 {
	 141  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
	 142  	}
	 143  	// Second call should timeout
	 144  	n, err = tor2.Read(b)
	 145  	if g, w := err, ErrTimeout; g != w {
	 146  		t.Errorf("Error mismatch\n\tGot:	%v\n\tWant: %v", g, w)
	 147  	}
	 148  	if g, w := n, 0; g != w {
	 149  		t.Errorf("Unexpectedly read %d bytes, wanted %d", g, w)
	 150  	}
	 151  }
	 152  
	 153  func TestTimeOutReader_emptyReader(t *testing.T) {
	 154  	r := new(bytes.Buffer)
	 155  	// empty read buffer
	 156  	tor := TimeoutReader(r)
	 157  	var b []byte
	 158  	if n, err := tor.Read(b); err != nil || n != 0 {
	 159  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
	 160  	}
	 161  	// Second call should timeout
	 162  	n, err := tor.Read(b)
	 163  	if g, w := err, ErrTimeout; g != w {
	 164  		t.Errorf("Error mismatch\n\tGot:	%v\n\tWant: %v", g, w)
	 165  	}
	 166  	if g, w := n, 0; g != w {
	 167  		t.Errorf("Unexpectedly read %d bytes, wanted %d", g, w)
	 168  	}
	 169  	// non empty read buffer
	 170  	tor2 := TimeoutReader(r)
	 171  	b = make([]byte, 5)
	 172  	if n, err := tor2.Read(b); err != io.EOF || n != 0 {
	 173  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
	 174  	}
	 175  	// Second call should timeout
	 176  	n, err = tor2.Read(b)
	 177  	if g, w := err, ErrTimeout; g != w {
	 178  		t.Errorf("Error mismatch\n\tGot:	%v\n\tWant: %v", g, w)
	 179  	}
	 180  	if g, w := n, 0; g != w {
	 181  		t.Errorf("Unexpectedly read %d bytes, wanted %d", g, w)
	 182  	}
	 183  }
	 184  
	 185  func TestDataErrReader_nonEmptyReader(t *testing.T) {
	 186  	msg := "Hello, World!"
	 187  	buf := new(bytes.Buffer)
	 188  	buf.WriteString(msg)
	 189  
	 190  	der := DataErrReader(buf)
	 191  
	 192  	b := make([]byte, 3)
	 193  	got := new(bytes.Buffer)
	 194  	var n int
	 195  	var err error
	 196  	for {
	 197  		n, err = der.Read(b)
	 198  		got.Write(b[:n])
	 199  		if err != nil {
	 200  			break
	 201  		}
	 202  	}
	 203  	if err != io.EOF || n == 0 {
	 204  		t.Errorf("Last Read returned n=%d err=%v", n, err)
	 205  	}
	 206  	if g, w := got.String(), "Hello, World!"; g != w {
	 207  		t.Errorf("Read mismatch\n\tGot:	%q\n\tWant: %q", g, w)
	 208  	}
	 209  }
	 210  
	 211  func TestDataErrReader_emptyReader(t *testing.T) {
	 212  	r := new(bytes.Buffer)
	 213  
	 214  	der := DataErrReader(r)
	 215  	var b []byte
	 216  	if n, err := der.Read(b); err != io.EOF || n != 0 {
	 217  		t.Errorf("Empty buffer read returned n=%d err=%v", n, err)
	 218  	}
	 219  
	 220  	b = make([]byte, 5)
	 221  	n, err := der.Read(b)
	 222  	if g, w := err, io.EOF; g != w {
	 223  		t.Errorf("Error mismatch\n\tGot:	%v\n\tWant: %v", g, w)
	 224  	}
	 225  	if g, w := n, 0; g != w {
	 226  		t.Errorf("Unexpectedly read %d bytes, wanted %d", g, w)
	 227  	}
	 228  }
	 229  
	 230  func TestErrReader(t *testing.T) {
	 231  	cases := []struct {
	 232  		name string
	 233  		err	error
	 234  	}{
	 235  		{"nil error", nil},
	 236  		{"non-nil error", errors.New("io failure")},
	 237  		{"io.EOF", io.EOF},
	 238  	}
	 239  
	 240  	for _, tt := range cases {
	 241  		tt := tt
	 242  		t.Run(tt.name, func(t *testing.T) {
	 243  			n, err := ErrReader(tt.err).Read(nil)
	 244  			if err != tt.err {
	 245  				t.Fatalf("Error mismatch\nGot:	%v\nWant: %v", err, tt.err)
	 246  			}
	 247  			if n != 0 {
	 248  				t.Fatalf("Byte count mismatch: got %d want 0", n)
	 249  			}
	 250  		})
	 251  	}
	 252  }
	 253  
	 254  func TestStringsReader(t *testing.T) {
	 255  	const msg = "Now is the time for all good gophers."
	 256  
	 257  	r := strings.NewReader(msg)
	 258  	if err := TestReader(r, []byte(msg)); err != nil {
	 259  		t.Fatal(err)
	 260  	}
	 261  }
	 262
View as plain text