Source file src/bufio/bufio_test.go

Documentation: bufio

		 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 bufio_test
		 6  
		 7  import (
		 8  	. "bufio"
		 9  	"bytes"
		10  	"errors"
		11  	"fmt"
		12  	"io"
		13  	"strings"
		14  	"testing"
		15  	"testing/iotest"
		16  	"time"
		17  	"unicode/utf8"
		18  )
		19  
		20  // Reads from a reader and rot13s the result.
		21  type rot13Reader struct {
		22  	r io.Reader
		23  }
		24  
		25  func newRot13Reader(r io.Reader) *rot13Reader {
		26  	r13 := new(rot13Reader)
		27  	r13.r = r
		28  	return r13
		29  }
		30  
		31  func (r13 *rot13Reader) Read(p []byte) (int, error) {
		32  	n, err := r13.r.Read(p)
		33  	for i := 0; i < n; i++ {
		34  		c := p[i] | 0x20 // lowercase byte
		35  		if 'a' <= c && c <= 'm' {
		36  			p[i] += 13
		37  		} else if 'n' <= c && c <= 'z' {
		38  			p[i] -= 13
		39  		}
		40  	}
		41  	return n, err
		42  }
		43  
		44  // Call ReadByte to accumulate the text of a file
		45  func readBytes(buf *Reader) string {
		46  	var b [1000]byte
		47  	nb := 0
		48  	for {
		49  		c, err := buf.ReadByte()
		50  		if err == io.EOF {
		51  			break
		52  		}
		53  		if err == nil {
		54  			b[nb] = c
		55  			nb++
		56  		} else if err != iotest.ErrTimeout {
		57  			panic("Data: " + err.Error())
		58  		}
		59  	}
		60  	return string(b[0:nb])
		61  }
		62  
		63  func TestReaderSimple(t *testing.T) {
		64  	data := "hello world"
		65  	b := NewReader(strings.NewReader(data))
		66  	if s := readBytes(b); s != "hello world" {
		67  		t.Errorf("simple hello world test failed: got %q", s)
		68  	}
		69  
		70  	b = NewReader(newRot13Reader(strings.NewReader(data)))
		71  	if s := readBytes(b); s != "uryyb jbeyq" {
		72  		t.Errorf("rot13 hello world test failed: got %q", s)
		73  	}
		74  }
		75  
		76  type readMaker struct {
		77  	name string
		78  	fn	 func(io.Reader) io.Reader
		79  }
		80  
		81  var readMakers = []readMaker{
		82  	{"full", func(r io.Reader) io.Reader { return r }},
		83  	{"byte", iotest.OneByteReader},
		84  	{"half", iotest.HalfReader},
		85  	{"data+err", iotest.DataErrReader},
		86  	{"timeout", iotest.TimeoutReader},
		87  }
		88  
		89  // Call ReadString (which ends up calling everything else)
		90  // to accumulate the text of a file.
		91  func readLines(b *Reader) string {
		92  	s := ""
		93  	for {
		94  		s1, err := b.ReadString('\n')
		95  		if err == io.EOF {
		96  			break
		97  		}
		98  		if err != nil && err != iotest.ErrTimeout {
		99  			panic("GetLines: " + err.Error())
	 100  		}
	 101  		s += s1
	 102  	}
	 103  	return s
	 104  }
	 105  
	 106  // Call Read to accumulate the text of a file
	 107  func reads(buf *Reader, m int) string {
	 108  	var b [1000]byte
	 109  	nb := 0
	 110  	for {
	 111  		n, err := buf.Read(b[nb : nb+m])
	 112  		nb += n
	 113  		if err == io.EOF {
	 114  			break
	 115  		}
	 116  	}
	 117  	return string(b[0:nb])
	 118  }
	 119  
	 120  type bufReader struct {
	 121  	name string
	 122  	fn	 func(*Reader) string
	 123  }
	 124  
	 125  var bufreaders = []bufReader{
	 126  	{"1", func(b *Reader) string { return reads(b, 1) }},
	 127  	{"2", func(b *Reader) string { return reads(b, 2) }},
	 128  	{"3", func(b *Reader) string { return reads(b, 3) }},
	 129  	{"4", func(b *Reader) string { return reads(b, 4) }},
	 130  	{"5", func(b *Reader) string { return reads(b, 5) }},
	 131  	{"7", func(b *Reader) string { return reads(b, 7) }},
	 132  	{"bytes", readBytes},
	 133  	{"lines", readLines},
	 134  }
	 135  
	 136  const minReadBufferSize = 16
	 137  
	 138  var bufsizes = []int{
	 139  	0, minReadBufferSize, 23, 32, 46, 64, 93, 128, 1024, 4096,
	 140  }
	 141  
	 142  func TestReader(t *testing.T) {
	 143  	var texts [31]string
	 144  	str := ""
	 145  	all := ""
	 146  	for i := 0; i < len(texts)-1; i++ {
	 147  		texts[i] = str + "\n"
	 148  		all += texts[i]
	 149  		str += string(rune(i%26 + 'a'))
	 150  	}
	 151  	texts[len(texts)-1] = all
	 152  
	 153  	for h := 0; h < len(texts); h++ {
	 154  		text := texts[h]
	 155  		for i := 0; i < len(readMakers); i++ {
	 156  			for j := 0; j < len(bufreaders); j++ {
	 157  				for k := 0; k < len(bufsizes); k++ {
	 158  					readmaker := readMakers[i]
	 159  					bufreader := bufreaders[j]
	 160  					bufsize := bufsizes[k]
	 161  					read := readmaker.fn(strings.NewReader(text))
	 162  					buf := NewReaderSize(read, bufsize)
	 163  					s := bufreader.fn(buf)
	 164  					if s != text {
	 165  						t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
	 166  							readmaker.name, bufreader.name, bufsize, text, s)
	 167  					}
	 168  				}
	 169  			}
	 170  		}
	 171  	}
	 172  }
	 173  
	 174  type zeroReader struct{}
	 175  
	 176  func (zeroReader) Read(p []byte) (int, error) {
	 177  	return 0, nil
	 178  }
	 179  
	 180  func TestZeroReader(t *testing.T) {
	 181  	var z zeroReader
	 182  	r := NewReader(z)
	 183  
	 184  	c := make(chan error)
	 185  	go func() {
	 186  		_, err := r.ReadByte()
	 187  		c <- err
	 188  	}()
	 189  
	 190  	select {
	 191  	case err := <-c:
	 192  		if err == nil {
	 193  			t.Error("error expected")
	 194  		} else if err != io.ErrNoProgress {
	 195  			t.Error("unexpected error:", err)
	 196  		}
	 197  	case <-time.After(time.Second):
	 198  		t.Error("test timed out (endless loop in ReadByte?)")
	 199  	}
	 200  }
	 201  
	 202  // A StringReader delivers its data one string segment at a time via Read.
	 203  type StringReader struct {
	 204  	data []string
	 205  	step int
	 206  }
	 207  
	 208  func (r *StringReader) Read(p []byte) (n int, err error) {
	 209  	if r.step < len(r.data) {
	 210  		s := r.data[r.step]
	 211  		n = copy(p, s)
	 212  		r.step++
	 213  	} else {
	 214  		err = io.EOF
	 215  	}
	 216  	return
	 217  }
	 218  
	 219  func readRuneSegments(t *testing.T, segments []string) {
	 220  	got := ""
	 221  	want := strings.Join(segments, "")
	 222  	r := NewReader(&StringReader{data: segments})
	 223  	for {
	 224  		r, _, err := r.ReadRune()
	 225  		if err != nil {
	 226  			if err != io.EOF {
	 227  				return
	 228  			}
	 229  			break
	 230  		}
	 231  		got += string(r)
	 232  	}
	 233  	if got != want {
	 234  		t.Errorf("segments=%v got=%s want=%s", segments, got, want)
	 235  	}
	 236  }
	 237  
	 238  var segmentList = [][]string{
	 239  	{},
	 240  	{""},
	 241  	{"日", "本語"},
	 242  	{"\u65e5", "\u672c", "\u8a9e"},
	 243  	{"\U000065e5", "\U0000672c", "\U00008a9e"},
	 244  	{"\xe6", "\x97\xa5\xe6", "\x9c\xac\xe8\xaa\x9e"},
	 245  	{"Hello", ", ", "World", "!"},
	 246  	{"Hello", ", ", "", "World", "!"},
	 247  }
	 248  
	 249  func TestReadRune(t *testing.T) {
	 250  	for _, s := range segmentList {
	 251  		readRuneSegments(t, s)
	 252  	}
	 253  }
	 254  
	 255  func TestUnreadRune(t *testing.T) {
	 256  	segments := []string{"Hello, world:", "日本語"}
	 257  	r := NewReader(&StringReader{data: segments})
	 258  	got := ""
	 259  	want := strings.Join(segments, "")
	 260  	// Normal execution.
	 261  	for {
	 262  		r1, _, err := r.ReadRune()
	 263  		if err != nil {
	 264  			if err != io.EOF {
	 265  				t.Error("unexpected error on ReadRune:", err)
	 266  			}
	 267  			break
	 268  		}
	 269  		got += string(r1)
	 270  		// Put it back and read it again.
	 271  		if err = r.UnreadRune(); err != nil {
	 272  			t.Fatal("unexpected error on UnreadRune:", err)
	 273  		}
	 274  		r2, _, err := r.ReadRune()
	 275  		if err != nil {
	 276  			t.Fatal("unexpected error reading after unreading:", err)
	 277  		}
	 278  		if r1 != r2 {
	 279  			t.Fatalf("incorrect rune after unread: got %c, want %c", r1, r2)
	 280  		}
	 281  	}
	 282  	if got != want {
	 283  		t.Errorf("got %q, want %q", got, want)
	 284  	}
	 285  }
	 286  
	 287  func TestNoUnreadRuneAfterPeek(t *testing.T) {
	 288  	br := NewReader(strings.NewReader("example"))
	 289  	br.ReadRune()
	 290  	br.Peek(1)
	 291  	if err := br.UnreadRune(); err == nil {
	 292  		t.Error("UnreadRune didn't fail after Peek")
	 293  	}
	 294  }
	 295  
	 296  func TestNoUnreadByteAfterPeek(t *testing.T) {
	 297  	br := NewReader(strings.NewReader("example"))
	 298  	br.ReadByte()
	 299  	br.Peek(1)
	 300  	if err := br.UnreadByte(); err == nil {
	 301  		t.Error("UnreadByte didn't fail after Peek")
	 302  	}
	 303  }
	 304  
	 305  func TestUnreadByte(t *testing.T) {
	 306  	segments := []string{"Hello, ", "world"}
	 307  	r := NewReader(&StringReader{data: segments})
	 308  	got := ""
	 309  	want := strings.Join(segments, "")
	 310  	// Normal execution.
	 311  	for {
	 312  		b1, err := r.ReadByte()
	 313  		if err != nil {
	 314  			if err != io.EOF {
	 315  				t.Error("unexpected error on ReadByte:", err)
	 316  			}
	 317  			break
	 318  		}
	 319  		got += string(b1)
	 320  		// Put it back and read it again.
	 321  		if err = r.UnreadByte(); err != nil {
	 322  			t.Fatal("unexpected error on UnreadByte:", err)
	 323  		}
	 324  		b2, err := r.ReadByte()
	 325  		if err != nil {
	 326  			t.Fatal("unexpected error reading after unreading:", err)
	 327  		}
	 328  		if b1 != b2 {
	 329  			t.Fatalf("incorrect byte after unread: got %q, want %q", b1, b2)
	 330  		}
	 331  	}
	 332  	if got != want {
	 333  		t.Errorf("got %q, want %q", got, want)
	 334  	}
	 335  }
	 336  
	 337  func TestUnreadByteMultiple(t *testing.T) {
	 338  	segments := []string{"Hello, ", "world"}
	 339  	data := strings.Join(segments, "")
	 340  	for n := 0; n <= len(data); n++ {
	 341  		r := NewReader(&StringReader{data: segments})
	 342  		// Read n bytes.
	 343  		for i := 0; i < n; i++ {
	 344  			b, err := r.ReadByte()
	 345  			if err != nil {
	 346  				t.Fatalf("n = %d: unexpected error on ReadByte: %v", n, err)
	 347  			}
	 348  			if b != data[i] {
	 349  				t.Fatalf("n = %d: incorrect byte returned from ReadByte: got %q, want %q", n, b, data[i])
	 350  			}
	 351  		}
	 352  		// Unread one byte if there is one.
	 353  		if n > 0 {
	 354  			if err := r.UnreadByte(); err != nil {
	 355  				t.Errorf("n = %d: unexpected error on UnreadByte: %v", n, err)
	 356  			}
	 357  		}
	 358  		// Test that we cannot unread any further.
	 359  		if err := r.UnreadByte(); err == nil {
	 360  			t.Errorf("n = %d: expected error on UnreadByte", n)
	 361  		}
	 362  	}
	 363  }
	 364  
	 365  func TestUnreadByteOthers(t *testing.T) {
	 366  	// A list of readers to use in conjunction with UnreadByte.
	 367  	var readers = []func(*Reader, byte) ([]byte, error){
	 368  		(*Reader).ReadBytes,
	 369  		(*Reader).ReadSlice,
	 370  		func(r *Reader, delim byte) ([]byte, error) {
	 371  			data, err := r.ReadString(delim)
	 372  			return []byte(data), err
	 373  		},
	 374  		// ReadLine doesn't fit the data/pattern easily
	 375  		// so we leave it out. It should be covered via
	 376  		// the ReadSlice test since ReadLine simply calls
	 377  		// ReadSlice, and it's that function that handles
	 378  		// the last byte.
	 379  	}
	 380  
	 381  	// Try all readers with UnreadByte.
	 382  	for rno, read := range readers {
	 383  		// Some input data that is longer than the minimum reader buffer size.
	 384  		const n = 10
	 385  		var buf bytes.Buffer
	 386  		for i := 0; i < n; i++ {
	 387  			buf.WriteString("abcdefg")
	 388  		}
	 389  
	 390  		r := NewReaderSize(&buf, minReadBufferSize)
	 391  		readTo := func(delim byte, want string) {
	 392  			data, err := read(r, delim)
	 393  			if err != nil {
	 394  				t.Fatalf("#%d: unexpected error reading to %c: %v", rno, delim, err)
	 395  			}
	 396  			if got := string(data); got != want {
	 397  				t.Fatalf("#%d: got %q, want %q", rno, got, want)
	 398  			}
	 399  		}
	 400  
	 401  		// Read the data with occasional UnreadByte calls.
	 402  		for i := 0; i < n; i++ {
	 403  			readTo('d', "abcd")
	 404  			for j := 0; j < 3; j++ {
	 405  				if err := r.UnreadByte(); err != nil {
	 406  					t.Fatalf("#%d: unexpected error on UnreadByte: %v", rno, err)
	 407  				}
	 408  				readTo('d', "d")
	 409  			}
	 410  			readTo('g', "efg")
	 411  		}
	 412  
	 413  		// All data should have been read.
	 414  		_, err := r.ReadByte()
	 415  		if err != io.EOF {
	 416  			t.Errorf("#%d: got error %v; want EOF", rno, err)
	 417  		}
	 418  	}
	 419  }
	 420  
	 421  // Test that UnreadRune fails if the preceding operation was not a ReadRune.
	 422  func TestUnreadRuneError(t *testing.T) {
	 423  	buf := make([]byte, 3) // All runes in this test are 3 bytes long
	 424  	r := NewReader(&StringReader{data: []string{"日本語日本語日本語"}})
	 425  	if r.UnreadRune() == nil {
	 426  		t.Error("expected error on UnreadRune from fresh buffer")
	 427  	}
	 428  	_, _, err := r.ReadRune()
	 429  	if err != nil {
	 430  		t.Error("unexpected error on ReadRune (1):", err)
	 431  	}
	 432  	if err = r.UnreadRune(); err != nil {
	 433  		t.Error("unexpected error on UnreadRune (1):", err)
	 434  	}
	 435  	if r.UnreadRune() == nil {
	 436  		t.Error("expected error after UnreadRune (1)")
	 437  	}
	 438  	// Test error after Read.
	 439  	_, _, err = r.ReadRune() // reset state
	 440  	if err != nil {
	 441  		t.Error("unexpected error on ReadRune (2):", err)
	 442  	}
	 443  	_, err = r.Read(buf)
	 444  	if err != nil {
	 445  		t.Error("unexpected error on Read (2):", err)
	 446  	}
	 447  	if r.UnreadRune() == nil {
	 448  		t.Error("expected error after Read (2)")
	 449  	}
	 450  	// Test error after ReadByte.
	 451  	_, _, err = r.ReadRune() // reset state
	 452  	if err != nil {
	 453  		t.Error("unexpected error on ReadRune (2):", err)
	 454  	}
	 455  	for range buf {
	 456  		_, err = r.ReadByte()
	 457  		if err != nil {
	 458  			t.Error("unexpected error on ReadByte (2):", err)
	 459  		}
	 460  	}
	 461  	if r.UnreadRune() == nil {
	 462  		t.Error("expected error after ReadByte")
	 463  	}
	 464  	// Test error after UnreadByte.
	 465  	_, _, err = r.ReadRune() // reset state
	 466  	if err != nil {
	 467  		t.Error("unexpected error on ReadRune (3):", err)
	 468  	}
	 469  	_, err = r.ReadByte()
	 470  	if err != nil {
	 471  		t.Error("unexpected error on ReadByte (3):", err)
	 472  	}
	 473  	err = r.UnreadByte()
	 474  	if err != nil {
	 475  		t.Error("unexpected error on UnreadByte (3):", err)
	 476  	}
	 477  	if r.UnreadRune() == nil {
	 478  		t.Error("expected error after UnreadByte (3)")
	 479  	}
	 480  	// Test error after ReadSlice.
	 481  	_, _, err = r.ReadRune() // reset state
	 482  	if err != nil {
	 483  		t.Error("unexpected error on ReadRune (4):", err)
	 484  	}
	 485  	_, err = r.ReadSlice(0)
	 486  	if err != io.EOF {
	 487  		t.Error("unexpected error on ReadSlice (4):", err)
	 488  	}
	 489  	if r.UnreadRune() == nil {
	 490  		t.Error("expected error after ReadSlice (4)")
	 491  	}
	 492  }
	 493  
	 494  func TestUnreadRuneAtEOF(t *testing.T) {
	 495  	// UnreadRune/ReadRune should error at EOF (was a bug; used to panic)
	 496  	r := NewReader(strings.NewReader("x"))
	 497  	r.ReadRune()
	 498  	r.ReadRune()
	 499  	r.UnreadRune()
	 500  	_, _, err := r.ReadRune()
	 501  	if err == nil {
	 502  		t.Error("expected error at EOF")
	 503  	} else if err != io.EOF {
	 504  		t.Error("expected EOF; got", err)
	 505  	}
	 506  }
	 507  
	 508  func TestReadWriteRune(t *testing.T) {
	 509  	const NRune = 1000
	 510  	byteBuf := new(bytes.Buffer)
	 511  	w := NewWriter(byteBuf)
	 512  	// Write the runes out using WriteRune
	 513  	buf := make([]byte, utf8.UTFMax)
	 514  	for r := rune(0); r < NRune; r++ {
	 515  		size := utf8.EncodeRune(buf, r)
	 516  		nbytes, err := w.WriteRune(r)
	 517  		if err != nil {
	 518  			t.Fatalf("WriteRune(0x%x) error: %s", r, err)
	 519  		}
	 520  		if nbytes != size {
	 521  			t.Fatalf("WriteRune(0x%x) expected %d, got %d", r, size, nbytes)
	 522  		}
	 523  	}
	 524  	w.Flush()
	 525  
	 526  	r := NewReader(byteBuf)
	 527  	// Read them back with ReadRune
	 528  	for r1 := rune(0); r1 < NRune; r1++ {
	 529  		size := utf8.EncodeRune(buf, r1)
	 530  		nr, nbytes, err := r.ReadRune()
	 531  		if nr != r1 || nbytes != size || err != nil {
	 532  			t.Fatalf("ReadRune(0x%x) got 0x%x,%d not 0x%x,%d (err=%s)", r1, nr, nbytes, r1, size, err)
	 533  		}
	 534  	}
	 535  }
	 536  
	 537  func TestWriteInvalidRune(t *testing.T) {
	 538  	// Invalid runes, including negative ones, should be written as the
	 539  	// replacement character.
	 540  	for _, r := range []rune{-1, utf8.MaxRune + 1} {
	 541  		var buf bytes.Buffer
	 542  		w := NewWriter(&buf)
	 543  		w.WriteRune(r)
	 544  		w.Flush()
	 545  		if s := buf.String(); s != "\uFFFD" {
	 546  			t.Errorf("WriteRune(%d) wrote %q, not replacement character", r, s)
	 547  		}
	 548  	}
	 549  }
	 550  
	 551  func TestReadStringAllocs(t *testing.T) {
	 552  	r := strings.NewReader("			 foo			 foo				42				42				42				42				42				42				42				42			 4.2			 4.2			 4.2			 4.2\n")
	 553  	buf := NewReader(r)
	 554  	allocs := testing.AllocsPerRun(100, func() {
	 555  		r.Seek(0, io.SeekStart)
	 556  		buf.Reset(r)
	 557  
	 558  		_, err := buf.ReadString('\n')
	 559  		if err != nil {
	 560  			t.Fatal(err)
	 561  		}
	 562  	})
	 563  	if allocs != 1 {
	 564  		t.Errorf("Unexpected number of allocations, got %f, want 1", allocs)
	 565  	}
	 566  }
	 567  
	 568  func TestWriter(t *testing.T) {
	 569  	var data [8192]byte
	 570  
	 571  	for i := 0; i < len(data); i++ {
	 572  		data[i] = byte(' ' + i%('~'-' '))
	 573  	}
	 574  	w := new(bytes.Buffer)
	 575  	for i := 0; i < len(bufsizes); i++ {
	 576  		for j := 0; j < len(bufsizes); j++ {
	 577  			nwrite := bufsizes[i]
	 578  			bs := bufsizes[j]
	 579  
	 580  			// Write nwrite bytes using buffer size bs.
	 581  			// Check that the right amount makes it out
	 582  			// and that the data is correct.
	 583  
	 584  			w.Reset()
	 585  			buf := NewWriterSize(w, bs)
	 586  			context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs)
	 587  			n, e1 := buf.Write(data[0:nwrite])
	 588  			if e1 != nil || n != nwrite {
	 589  				t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1)
	 590  				continue
	 591  			}
	 592  			if e := buf.Flush(); e != nil {
	 593  				t.Errorf("%s: buf.Flush = %v", context, e)
	 594  			}
	 595  
	 596  			written := w.Bytes()
	 597  			if len(written) != nwrite {
	 598  				t.Errorf("%s: %d bytes written", context, len(written))
	 599  			}
	 600  			for l := 0; l < len(written); l++ {
	 601  				if written[l] != data[l] {
	 602  					t.Errorf("wrong bytes written")
	 603  					t.Errorf("want=%q", data[0:len(written)])
	 604  					t.Errorf("have=%q", written)
	 605  				}
	 606  			}
	 607  		}
	 608  	}
	 609  }
	 610  
	 611  // Check that write errors are returned properly.
	 612  
	 613  type errorWriterTest struct {
	 614  	n, m	 int
	 615  	err		error
	 616  	expect error
	 617  }
	 618  
	 619  func (w errorWriterTest) Write(p []byte) (int, error) {
	 620  	return len(p) * w.n / w.m, w.err
	 621  }
	 622  
	 623  var errorWriterTests = []errorWriterTest{
	 624  	{0, 1, nil, io.ErrShortWrite},
	 625  	{1, 2, nil, io.ErrShortWrite},
	 626  	{1, 1, nil, nil},
	 627  	{0, 1, io.ErrClosedPipe, io.ErrClosedPipe},
	 628  	{1, 2, io.ErrClosedPipe, io.ErrClosedPipe},
	 629  	{1, 1, io.ErrClosedPipe, io.ErrClosedPipe},
	 630  }
	 631  
	 632  func TestWriteErrors(t *testing.T) {
	 633  	for _, w := range errorWriterTests {
	 634  		buf := NewWriter(w)
	 635  		_, e := buf.Write([]byte("hello world"))
	 636  		if e != nil {
	 637  			t.Errorf("Write hello to %v: %v", w, e)
	 638  			continue
	 639  		}
	 640  		// Two flushes, to verify the error is sticky.
	 641  		for i := 0; i < 2; i++ {
	 642  			e = buf.Flush()
	 643  			if e != w.expect {
	 644  				t.Errorf("Flush %d/2 %v: got %v, wanted %v", i+1, w, e, w.expect)
	 645  			}
	 646  		}
	 647  	}
	 648  }
	 649  
	 650  func TestNewReaderSizeIdempotent(t *testing.T) {
	 651  	const BufSize = 1000
	 652  	b := NewReaderSize(strings.NewReader("hello world"), BufSize)
	 653  	// Does it recognize itself?
	 654  	b1 := NewReaderSize(b, BufSize)
	 655  	if b1 != b {
	 656  		t.Error("NewReaderSize did not detect underlying Reader")
	 657  	}
	 658  	// Does it wrap if existing buffer is too small?
	 659  	b2 := NewReaderSize(b, 2*BufSize)
	 660  	if b2 == b {
	 661  		t.Error("NewReaderSize did not enlarge buffer")
	 662  	}
	 663  }
	 664  
	 665  func TestNewWriterSizeIdempotent(t *testing.T) {
	 666  	const BufSize = 1000
	 667  	b := NewWriterSize(new(bytes.Buffer), BufSize)
	 668  	// Does it recognize itself?
	 669  	b1 := NewWriterSize(b, BufSize)
	 670  	if b1 != b {
	 671  		t.Error("NewWriterSize did not detect underlying Writer")
	 672  	}
	 673  	// Does it wrap if existing buffer is too small?
	 674  	b2 := NewWriterSize(b, 2*BufSize)
	 675  	if b2 == b {
	 676  		t.Error("NewWriterSize did not enlarge buffer")
	 677  	}
	 678  }
	 679  
	 680  func TestWriteString(t *testing.T) {
	 681  	const BufSize = 8
	 682  	buf := new(bytes.Buffer)
	 683  	b := NewWriterSize(buf, BufSize)
	 684  	b.WriteString("0")												 // easy
	 685  	b.WriteString("123456")										// still easy
	 686  	b.WriteString("7890")											// easy after flush
	 687  	b.WriteString("abcdefghijklmnopqrstuvwxy") // hard
	 688  	b.WriteString("z")
	 689  	if err := b.Flush(); err != nil {
	 690  		t.Error("WriteString", err)
	 691  	}
	 692  	s := "01234567890abcdefghijklmnopqrstuvwxyz"
	 693  	if string(buf.Bytes()) != s {
	 694  		t.Errorf("WriteString wants %q gets %q", s, string(buf.Bytes()))
	 695  	}
	 696  }
	 697  
	 698  func TestBufferFull(t *testing.T) {
	 699  	const longString = "And now, hello, world! It is the time for all good men to come to the aid of their party"
	 700  	buf := NewReaderSize(strings.NewReader(longString), minReadBufferSize)
	 701  	line, err := buf.ReadSlice('!')
	 702  	if string(line) != "And now, hello, " || err != ErrBufferFull {
	 703  		t.Errorf("first ReadSlice(,) = %q, %v", line, err)
	 704  	}
	 705  	line, err = buf.ReadSlice('!')
	 706  	if string(line) != "world!" || err != nil {
	 707  		t.Errorf("second ReadSlice(,) = %q, %v", line, err)
	 708  	}
	 709  }
	 710  
	 711  func TestPeek(t *testing.T) {
	 712  	p := make([]byte, 10)
	 713  	// string is 16 (minReadBufferSize) long.
	 714  	buf := NewReaderSize(strings.NewReader("abcdefghijklmnop"), minReadBufferSize)
	 715  	if s, err := buf.Peek(1); string(s) != "a" || err != nil {
	 716  		t.Fatalf("want %q got %q, err=%v", "a", string(s), err)
	 717  	}
	 718  	if s, err := buf.Peek(4); string(s) != "abcd" || err != nil {
	 719  		t.Fatalf("want %q got %q, err=%v", "abcd", string(s), err)
	 720  	}
	 721  	if _, err := buf.Peek(-1); err != ErrNegativeCount {
	 722  		t.Fatalf("want ErrNegativeCount got %v", err)
	 723  	}
	 724  	if s, err := buf.Peek(32); string(s) != "abcdefghijklmnop" || err != ErrBufferFull {
	 725  		t.Fatalf("want %q, ErrBufFull got %q, err=%v", "abcdefghijklmnop", string(s), err)
	 726  	}
	 727  	if _, err := buf.Read(p[0:3]); string(p[0:3]) != "abc" || err != nil {
	 728  		t.Fatalf("want %q got %q, err=%v", "abc", string(p[0:3]), err)
	 729  	}
	 730  	if s, err := buf.Peek(1); string(s) != "d" || err != nil {
	 731  		t.Fatalf("want %q got %q, err=%v", "d", string(s), err)
	 732  	}
	 733  	if s, err := buf.Peek(2); string(s) != "de" || err != nil {
	 734  		t.Fatalf("want %q got %q, err=%v", "de", string(s), err)
	 735  	}
	 736  	if _, err := buf.Read(p[0:3]); string(p[0:3]) != "def" || err != nil {
	 737  		t.Fatalf("want %q got %q, err=%v", "def", string(p[0:3]), err)
	 738  	}
	 739  	if s, err := buf.Peek(4); string(s) != "ghij" || err != nil {
	 740  		t.Fatalf("want %q got %q, err=%v", "ghij", string(s), err)
	 741  	}
	 742  	if _, err := buf.Read(p[0:]); string(p[0:]) != "ghijklmnop" || err != nil {
	 743  		t.Fatalf("want %q got %q, err=%v", "ghijklmnop", string(p[0:minReadBufferSize]), err)
	 744  	}
	 745  	if s, err := buf.Peek(0); string(s) != "" || err != nil {
	 746  		t.Fatalf("want %q got %q, err=%v", "", string(s), err)
	 747  	}
	 748  	if _, err := buf.Peek(1); err != io.EOF {
	 749  		t.Fatalf("want EOF got %v", err)
	 750  	}
	 751  
	 752  	// Test for issue 3022, not exposing a reader's error on a successful Peek.
	 753  	buf = NewReaderSize(dataAndEOFReader("abcd"), 32)
	 754  	if s, err := buf.Peek(2); string(s) != "ab" || err != nil {
	 755  		t.Errorf(`Peek(2) on "abcd", EOF = %q, %v; want "ab", nil`, string(s), err)
	 756  	}
	 757  	if s, err := buf.Peek(4); string(s) != "abcd" || err != nil {
	 758  		t.Errorf(`Peek(4) on "abcd", EOF = %q, %v; want "abcd", nil`, string(s), err)
	 759  	}
	 760  	if n, err := buf.Read(p[0:5]); string(p[0:n]) != "abcd" || err != nil {
	 761  		t.Fatalf("Read after peek = %q, %v; want abcd, EOF", p[0:n], err)
	 762  	}
	 763  	if n, err := buf.Read(p[0:1]); string(p[0:n]) != "" || err != io.EOF {
	 764  		t.Fatalf(`second Read after peek = %q, %v; want "", EOF`, p[0:n], err)
	 765  	}
	 766  }
	 767  
	 768  type dataAndEOFReader string
	 769  
	 770  func (r dataAndEOFReader) Read(p []byte) (int, error) {
	 771  	return copy(p, r), io.EOF
	 772  }
	 773  
	 774  func TestPeekThenUnreadRune(t *testing.T) {
	 775  	// This sequence used to cause a crash.
	 776  	r := NewReader(strings.NewReader("x"))
	 777  	r.ReadRune()
	 778  	r.Peek(1)
	 779  	r.UnreadRune()
	 780  	r.ReadRune() // Used to panic here
	 781  }
	 782  
	 783  var testOutput = []byte("0123456789abcdefghijklmnopqrstuvwxy")
	 784  var testInput = []byte("012\n345\n678\n9ab\ncde\nfgh\nijk\nlmn\nopq\nrst\nuvw\nxy")
	 785  var testInputrn = []byte("012\r\n345\r\n678\r\n9ab\r\ncde\r\nfgh\r\nijk\r\nlmn\r\nopq\r\nrst\r\nuvw\r\nxy\r\n\n\r\n")
	 786  
	 787  // TestReader wraps a []byte and returns reads of a specific length.
	 788  type testReader struct {
	 789  	data	 []byte
	 790  	stride int
	 791  }
	 792  
	 793  func (t *testReader) Read(buf []byte) (n int, err error) {
	 794  	n = t.stride
	 795  	if n > len(t.data) {
	 796  		n = len(t.data)
	 797  	}
	 798  	if n > len(buf) {
	 799  		n = len(buf)
	 800  	}
	 801  	copy(buf, t.data)
	 802  	t.data = t.data[n:]
	 803  	if len(t.data) == 0 {
	 804  		err = io.EOF
	 805  	}
	 806  	return
	 807  }
	 808  
	 809  func testReadLine(t *testing.T, input []byte) {
	 810  	//for stride := 1; stride < len(input); stride++ {
	 811  	for stride := 1; stride < 2; stride++ {
	 812  		done := 0
	 813  		reader := testReader{input, stride}
	 814  		l := NewReaderSize(&reader, len(input)+1)
	 815  		for {
	 816  			line, isPrefix, err := l.ReadLine()
	 817  			if len(line) > 0 && err != nil {
	 818  				t.Errorf("ReadLine returned both data and error: %s", err)
	 819  			}
	 820  			if isPrefix {
	 821  				t.Errorf("ReadLine returned prefix")
	 822  			}
	 823  			if err != nil {
	 824  				if err != io.EOF {
	 825  					t.Fatalf("Got unknown error: %s", err)
	 826  				}
	 827  				break
	 828  			}
	 829  			if want := testOutput[done : done+len(line)]; !bytes.Equal(want, line) {
	 830  				t.Errorf("Bad line at stride %d: want: %x got: %x", stride, want, line)
	 831  			}
	 832  			done += len(line)
	 833  		}
	 834  		if done != len(testOutput) {
	 835  			t.Errorf("ReadLine didn't return everything: got: %d, want: %d (stride: %d)", done, len(testOutput), stride)
	 836  		}
	 837  	}
	 838  }
	 839  
	 840  func TestReadLine(t *testing.T) {
	 841  	testReadLine(t, testInput)
	 842  	testReadLine(t, testInputrn)
	 843  }
	 844  
	 845  func TestLineTooLong(t *testing.T) {
	 846  	data := make([]byte, 0)
	 847  	for i := 0; i < minReadBufferSize*5/2; i++ {
	 848  		data = append(data, '0'+byte(i%10))
	 849  	}
	 850  	buf := bytes.NewReader(data)
	 851  	l := NewReaderSize(buf, minReadBufferSize)
	 852  	line, isPrefix, err := l.ReadLine()
	 853  	if !isPrefix || !bytes.Equal(line, data[:minReadBufferSize]) || err != nil {
	 854  		t.Errorf("bad result for first line: got %q want %q %v", line, data[:minReadBufferSize], err)
	 855  	}
	 856  	data = data[len(line):]
	 857  	line, isPrefix, err = l.ReadLine()
	 858  	if !isPrefix || !bytes.Equal(line, data[:minReadBufferSize]) || err != nil {
	 859  		t.Errorf("bad result for second line: got %q want %q %v", line, data[:minReadBufferSize], err)
	 860  	}
	 861  	data = data[len(line):]
	 862  	line, isPrefix, err = l.ReadLine()
	 863  	if isPrefix || !bytes.Equal(line, data[:minReadBufferSize/2]) || err != nil {
	 864  		t.Errorf("bad result for third line: got %q want %q %v", line, data[:minReadBufferSize/2], err)
	 865  	}
	 866  	line, isPrefix, err = l.ReadLine()
	 867  	if isPrefix || err == nil {
	 868  		t.Errorf("expected no more lines: %x %s", line, err)
	 869  	}
	 870  }
	 871  
	 872  func TestReadAfterLines(t *testing.T) {
	 873  	line1 := "this is line1"
	 874  	restData := "this is line2\nthis is line 3\n"
	 875  	inbuf := bytes.NewReader([]byte(line1 + "\n" + restData))
	 876  	outbuf := new(bytes.Buffer)
	 877  	maxLineLength := len(line1) + len(restData)/2
	 878  	l := NewReaderSize(inbuf, maxLineLength)
	 879  	line, isPrefix, err := l.ReadLine()
	 880  	if isPrefix || err != nil || string(line) != line1 {
	 881  		t.Errorf("bad result for first line: isPrefix=%v err=%v line=%q", isPrefix, err, string(line))
	 882  	}
	 883  	n, err := io.Copy(outbuf, l)
	 884  	if int(n) != len(restData) || err != nil {
	 885  		t.Errorf("bad result for Read: n=%d err=%v", n, err)
	 886  	}
	 887  	if outbuf.String() != restData {
	 888  		t.Errorf("bad result for Read: got %q; expected %q", outbuf.String(), restData)
	 889  	}
	 890  }
	 891  
	 892  func TestReadEmptyBuffer(t *testing.T) {
	 893  	l := NewReaderSize(new(bytes.Buffer), minReadBufferSize)
	 894  	line, isPrefix, err := l.ReadLine()
	 895  	if err != io.EOF {
	 896  		t.Errorf("expected EOF from ReadLine, got '%s' %t %s", line, isPrefix, err)
	 897  	}
	 898  }
	 899  
	 900  func TestLinesAfterRead(t *testing.T) {
	 901  	l := NewReaderSize(bytes.NewReader([]byte("foo")), minReadBufferSize)
	 902  	_, err := io.ReadAll(l)
	 903  	if err != nil {
	 904  		t.Error(err)
	 905  		return
	 906  	}
	 907  
	 908  	line, isPrefix, err := l.ReadLine()
	 909  	if err != io.EOF {
	 910  		t.Errorf("expected EOF from ReadLine, got '%s' %t %s", line, isPrefix, err)
	 911  	}
	 912  }
	 913  
	 914  func TestReadLineNonNilLineOrError(t *testing.T) {
	 915  	r := NewReader(strings.NewReader("line 1\n"))
	 916  	for i := 0; i < 2; i++ {
	 917  		l, _, err := r.ReadLine()
	 918  		if l != nil && err != nil {
	 919  			t.Fatalf("on line %d/2; ReadLine=%#v, %v; want non-nil line or Error, but not both",
	 920  				i+1, l, err)
	 921  		}
	 922  	}
	 923  }
	 924  
	 925  type readLineResult struct {
	 926  	line		 []byte
	 927  	isPrefix bool
	 928  	err			error
	 929  }
	 930  
	 931  var readLineNewlinesTests = []struct {
	 932  	input	string
	 933  	expect []readLineResult
	 934  }{
	 935  	{"012345678901234\r\n012345678901234\r\n", []readLineResult{
	 936  		{[]byte("012345678901234"), true, nil},
	 937  		{nil, false, nil},
	 938  		{[]byte("012345678901234"), true, nil},
	 939  		{nil, false, nil},
	 940  		{nil, false, io.EOF},
	 941  	}},
	 942  	{"0123456789012345\r012345678901234\r", []readLineResult{
	 943  		{[]byte("0123456789012345"), true, nil},
	 944  		{[]byte("\r012345678901234"), true, nil},
	 945  		{[]byte("\r"), false, nil},
	 946  		{nil, false, io.EOF},
	 947  	}},
	 948  }
	 949  
	 950  func TestReadLineNewlines(t *testing.T) {
	 951  	for _, e := range readLineNewlinesTests {
	 952  		testReadLineNewlines(t, e.input, e.expect)
	 953  	}
	 954  }
	 955  
	 956  func testReadLineNewlines(t *testing.T, input string, expect []readLineResult) {
	 957  	b := NewReaderSize(strings.NewReader(input), minReadBufferSize)
	 958  	for i, e := range expect {
	 959  		line, isPrefix, err := b.ReadLine()
	 960  		if !bytes.Equal(line, e.line) {
	 961  			t.Errorf("%q call %d, line == %q, want %q", input, i, line, e.line)
	 962  			return
	 963  		}
	 964  		if isPrefix != e.isPrefix {
	 965  			t.Errorf("%q call %d, isPrefix == %v, want %v", input, i, isPrefix, e.isPrefix)
	 966  			return
	 967  		}
	 968  		if err != e.err {
	 969  			t.Errorf("%q call %d, err == %v, want %v", input, i, err, e.err)
	 970  			return
	 971  		}
	 972  	}
	 973  }
	 974  
	 975  func createTestInput(n int) []byte {
	 976  	input := make([]byte, n)
	 977  	for i := range input {
	 978  		// 101 and 251 are arbitrary prime numbers.
	 979  		// The idea is to create an input sequence
	 980  		// which doesn't repeat too frequently.
	 981  		input[i] = byte(i % 251)
	 982  		if i%101 == 0 {
	 983  			input[i] ^= byte(i / 101)
	 984  		}
	 985  	}
	 986  	return input
	 987  }
	 988  
	 989  func TestReaderWriteTo(t *testing.T) {
	 990  	input := createTestInput(8192)
	 991  	r := NewReader(onlyReader{bytes.NewReader(input)})
	 992  	w := new(bytes.Buffer)
	 993  	if n, err := r.WriteTo(w); err != nil || n != int64(len(input)) {
	 994  		t.Fatalf("r.WriteTo(w) = %d, %v, want %d, nil", n, err, len(input))
	 995  	}
	 996  
	 997  	for i, val := range w.Bytes() {
	 998  		if val != input[i] {
	 999  			t.Errorf("after write: out[%d] = %#x, want %#x", i, val, input[i])
	1000  		}
	1001  	}
	1002  }
	1003  
	1004  type errorWriterToTest struct {
	1005  	rn, wn		 int
	1006  	rerr, werr error
	1007  	expected	 error
	1008  }
	1009  
	1010  func (r errorWriterToTest) Read(p []byte) (int, error) {
	1011  	return len(p) * r.rn, r.rerr
	1012  }
	1013  
	1014  func (w errorWriterToTest) Write(p []byte) (int, error) {
	1015  	return len(p) * w.wn, w.werr
	1016  }
	1017  
	1018  var errorWriterToTests = []errorWriterToTest{
	1019  	{1, 0, nil, io.ErrClosedPipe, io.ErrClosedPipe},
	1020  	{0, 1, io.ErrClosedPipe, nil, io.ErrClosedPipe},
	1021  	{0, 0, io.ErrUnexpectedEOF, io.ErrClosedPipe, io.ErrClosedPipe},
	1022  	{0, 1, io.EOF, nil, nil},
	1023  }
	1024  
	1025  func TestReaderWriteToErrors(t *testing.T) {
	1026  	for i, rw := range errorWriterToTests {
	1027  		r := NewReader(rw)
	1028  		if _, err := r.WriteTo(rw); err != rw.expected {
	1029  			t.Errorf("r.WriteTo(errorWriterToTests[%d]) = _, %v, want _,%v", i, err, rw.expected)
	1030  		}
	1031  	}
	1032  }
	1033  
	1034  func TestWriterReadFrom(t *testing.T) {
	1035  	ws := []func(io.Writer) io.Writer{
	1036  		func(w io.Writer) io.Writer { return onlyWriter{w} },
	1037  		func(w io.Writer) io.Writer { return w },
	1038  	}
	1039  
	1040  	rs := []func(io.Reader) io.Reader{
	1041  		iotest.DataErrReader,
	1042  		func(r io.Reader) io.Reader { return r },
	1043  	}
	1044  
	1045  	for ri, rfunc := range rs {
	1046  		for wi, wfunc := range ws {
	1047  			input := createTestInput(8192)
	1048  			b := new(bytes.Buffer)
	1049  			w := NewWriter(wfunc(b))
	1050  			r := rfunc(bytes.NewReader(input))
	1051  			if n, err := w.ReadFrom(r); err != nil || n != int64(len(input)) {
	1052  				t.Errorf("ws[%d],rs[%d]: w.ReadFrom(r) = %d, %v, want %d, nil", wi, ri, n, err, len(input))
	1053  				continue
	1054  			}
	1055  			if err := w.Flush(); err != nil {
	1056  				t.Errorf("Flush returned %v", err)
	1057  				continue
	1058  			}
	1059  			if got, want := b.String(), string(input); got != want {
	1060  				t.Errorf("ws[%d], rs[%d]:\ngot	%q\nwant %q\n", wi, ri, got, want)
	1061  			}
	1062  		}
	1063  	}
	1064  }
	1065  
	1066  type errorReaderFromTest struct {
	1067  	rn, wn		 int
	1068  	rerr, werr error
	1069  	expected	 error
	1070  }
	1071  
	1072  func (r errorReaderFromTest) Read(p []byte) (int, error) {
	1073  	return len(p) * r.rn, r.rerr
	1074  }
	1075  
	1076  func (w errorReaderFromTest) Write(p []byte) (int, error) {
	1077  	return len(p) * w.wn, w.werr
	1078  }
	1079  
	1080  var errorReaderFromTests = []errorReaderFromTest{
	1081  	{0, 1, io.EOF, nil, nil},
	1082  	{1, 1, io.EOF, nil, nil},
	1083  	{0, 1, io.ErrClosedPipe, nil, io.ErrClosedPipe},
	1084  	{0, 0, io.ErrClosedPipe, io.ErrShortWrite, io.ErrClosedPipe},
	1085  	{1, 0, nil, io.ErrShortWrite, io.ErrShortWrite},
	1086  }
	1087  
	1088  func TestWriterReadFromErrors(t *testing.T) {
	1089  	for i, rw := range errorReaderFromTests {
	1090  		w := NewWriter(rw)
	1091  		if _, err := w.ReadFrom(rw); err != rw.expected {
	1092  			t.Errorf("w.ReadFrom(errorReaderFromTests[%d]) = _, %v, want _,%v", i, err, rw.expected)
	1093  		}
	1094  	}
	1095  }
	1096  
	1097  // TestWriterReadFromCounts tests that using io.Copy to copy into a
	1098  // bufio.Writer does not prematurely flush the buffer. For example, when
	1099  // buffering writes to a network socket, excessive network writes should be
	1100  // avoided.
	1101  func TestWriterReadFromCounts(t *testing.T) {
	1102  	var w0 writeCountingDiscard
	1103  	b0 := NewWriterSize(&w0, 1234)
	1104  	b0.WriteString(strings.Repeat("x", 1000))
	1105  	if w0 != 0 {
	1106  		t.Fatalf("write 1000 'x's: got %d writes, want 0", w0)
	1107  	}
	1108  	b0.WriteString(strings.Repeat("x", 200))
	1109  	if w0 != 0 {
	1110  		t.Fatalf("write 1200 'x's: got %d writes, want 0", w0)
	1111  	}
	1112  	io.Copy(b0, onlyReader{strings.NewReader(strings.Repeat("x", 30))})
	1113  	if w0 != 0 {
	1114  		t.Fatalf("write 1230 'x's: got %d writes, want 0", w0)
	1115  	}
	1116  	io.Copy(b0, onlyReader{strings.NewReader(strings.Repeat("x", 9))})
	1117  	if w0 != 1 {
	1118  		t.Fatalf("write 1239 'x's: got %d writes, want 1", w0)
	1119  	}
	1120  
	1121  	var w1 writeCountingDiscard
	1122  	b1 := NewWriterSize(&w1, 1234)
	1123  	b1.WriteString(strings.Repeat("x", 1200))
	1124  	b1.Flush()
	1125  	if w1 != 1 {
	1126  		t.Fatalf("flush 1200 'x's: got %d writes, want 1", w1)
	1127  	}
	1128  	b1.WriteString(strings.Repeat("x", 89))
	1129  	if w1 != 1 {
	1130  		t.Fatalf("write 1200 + 89 'x's: got %d writes, want 1", w1)
	1131  	}
	1132  	io.Copy(b1, onlyReader{strings.NewReader(strings.Repeat("x", 700))})
	1133  	if w1 != 1 {
	1134  		t.Fatalf("write 1200 + 789 'x's: got %d writes, want 1", w1)
	1135  	}
	1136  	io.Copy(b1, onlyReader{strings.NewReader(strings.Repeat("x", 600))})
	1137  	if w1 != 2 {
	1138  		t.Fatalf("write 1200 + 1389 'x's: got %d writes, want 2", w1)
	1139  	}
	1140  	b1.Flush()
	1141  	if w1 != 3 {
	1142  		t.Fatalf("flush 1200 + 1389 'x's: got %d writes, want 3", w1)
	1143  	}
	1144  }
	1145  
	1146  // A writeCountingDiscard is like io.Discard and counts the number of times
	1147  // Write is called on it.
	1148  type writeCountingDiscard int
	1149  
	1150  func (w *writeCountingDiscard) Write(p []byte) (int, error) {
	1151  	*w++
	1152  	return len(p), nil
	1153  }
	1154  
	1155  type negativeReader int
	1156  
	1157  func (r *negativeReader) Read([]byte) (int, error) { return -1, nil }
	1158  
	1159  func TestNegativeRead(t *testing.T) {
	1160  	// should panic with a description pointing at the reader, not at itself.
	1161  	// (should NOT panic with slice index error, for example.)
	1162  	b := NewReader(new(negativeReader))
	1163  	defer func() {
	1164  		switch err := recover().(type) {
	1165  		case nil:
	1166  			t.Fatal("read did not panic")
	1167  		case error:
	1168  			if !strings.Contains(err.Error(), "reader returned negative count from Read") {
	1169  				t.Fatalf("wrong panic: %v", err)
	1170  			}
	1171  		default:
	1172  			t.Fatalf("unexpected panic value: %T(%v)", err, err)
	1173  		}
	1174  	}()
	1175  	b.Read(make([]byte, 100))
	1176  }
	1177  
	1178  var errFake = errors.New("fake error")
	1179  
	1180  type errorThenGoodReader struct {
	1181  	didErr bool
	1182  	nread	int
	1183  }
	1184  
	1185  func (r *errorThenGoodReader) Read(p []byte) (int, error) {
	1186  	r.nread++
	1187  	if !r.didErr {
	1188  		r.didErr = true
	1189  		return 0, errFake
	1190  	}
	1191  	return len(p), nil
	1192  }
	1193  
	1194  func TestReaderClearError(t *testing.T) {
	1195  	r := &errorThenGoodReader{}
	1196  	b := NewReader(r)
	1197  	buf := make([]byte, 1)
	1198  	if _, err := b.Read(nil); err != nil {
	1199  		t.Fatalf("1st nil Read = %v; want nil", err)
	1200  	}
	1201  	if _, err := b.Read(buf); err != errFake {
	1202  		t.Fatalf("1st Read = %v; want errFake", err)
	1203  	}
	1204  	if _, err := b.Read(nil); err != nil {
	1205  		t.Fatalf("2nd nil Read = %v; want nil", err)
	1206  	}
	1207  	if _, err := b.Read(buf); err != nil {
	1208  		t.Fatalf("3rd Read with buffer = %v; want nil", err)
	1209  	}
	1210  	if r.nread != 2 {
	1211  		t.Errorf("num reads = %d; want 2", r.nread)
	1212  	}
	1213  }
	1214  
	1215  // Test for golang.org/issue/5947
	1216  func TestWriterReadFromWhileFull(t *testing.T) {
	1217  	buf := new(bytes.Buffer)
	1218  	w := NewWriterSize(buf, 10)
	1219  
	1220  	// Fill buffer exactly.
	1221  	n, err := w.Write([]byte("0123456789"))
	1222  	if n != 10 || err != nil {
	1223  		t.Fatalf("Write returned (%v, %v), want (10, nil)", n, err)
	1224  	}
	1225  
	1226  	// Use ReadFrom to read in some data.
	1227  	n2, err := w.ReadFrom(strings.NewReader("abcdef"))
	1228  	if n2 != 6 || err != nil {
	1229  		t.Fatalf("ReadFrom returned (%v, %v), want (6, nil)", n2, err)
	1230  	}
	1231  }
	1232  
	1233  type emptyThenNonEmptyReader struct {
	1234  	r io.Reader
	1235  	n int
	1236  }
	1237  
	1238  func (r *emptyThenNonEmptyReader) Read(p []byte) (int, error) {
	1239  	if r.n <= 0 {
	1240  		return r.r.Read(p)
	1241  	}
	1242  	r.n--
	1243  	return 0, nil
	1244  }
	1245  
	1246  // Test for golang.org/issue/7611
	1247  func TestWriterReadFromUntilEOF(t *testing.T) {
	1248  	buf := new(bytes.Buffer)
	1249  	w := NewWriterSize(buf, 5)
	1250  
	1251  	// Partially fill buffer
	1252  	n, err := w.Write([]byte("0123"))
	1253  	if n != 4 || err != nil {
	1254  		t.Fatalf("Write returned (%v, %v), want (4, nil)", n, err)
	1255  	}
	1256  
	1257  	// Use ReadFrom to read in some data.
	1258  	r := &emptyThenNonEmptyReader{r: strings.NewReader("abcd"), n: 3}
	1259  	n2, err := w.ReadFrom(r)
	1260  	if n2 != 4 || err != nil {
	1261  		t.Fatalf("ReadFrom returned (%v, %v), want (4, nil)", n2, err)
	1262  	}
	1263  	w.Flush()
	1264  	if got, want := string(buf.Bytes()), "0123abcd"; got != want {
	1265  		t.Fatalf("buf.Bytes() returned %q, want %q", got, want)
	1266  	}
	1267  }
	1268  
	1269  func TestWriterReadFromErrNoProgress(t *testing.T) {
	1270  	buf := new(bytes.Buffer)
	1271  	w := NewWriterSize(buf, 5)
	1272  
	1273  	// Partially fill buffer
	1274  	n, err := w.Write([]byte("0123"))
	1275  	if n != 4 || err != nil {
	1276  		t.Fatalf("Write returned (%v, %v), want (4, nil)", n, err)
	1277  	}
	1278  
	1279  	// Use ReadFrom to read in some data.
	1280  	r := &emptyThenNonEmptyReader{r: strings.NewReader("abcd"), n: 100}
	1281  	n2, err := w.ReadFrom(r)
	1282  	if n2 != 0 || err != io.ErrNoProgress {
	1283  		t.Fatalf("buf.Bytes() returned (%v, %v), want (0, io.ErrNoProgress)", n2, err)
	1284  	}
	1285  }
	1286  
	1287  func TestReadZero(t *testing.T) {
	1288  	for _, size := range []int{100, 2} {
	1289  		t.Run(fmt.Sprintf("bufsize=%d", size), func(t *testing.T) {
	1290  			r := io.MultiReader(strings.NewReader("abc"), &emptyThenNonEmptyReader{r: strings.NewReader("def"), n: 1})
	1291  			br := NewReaderSize(r, size)
	1292  			want := func(s string, wantErr error) {
	1293  				p := make([]byte, 50)
	1294  				n, err := br.Read(p)
	1295  				if err != wantErr || n != len(s) || string(p[:n]) != s {
	1296  					t.Fatalf("read(%d) = %q, %v, want %q, %v", len(p), string(p[:n]), err, s, wantErr)
	1297  				}
	1298  				t.Logf("read(%d) = %q, %v", len(p), string(p[:n]), err)
	1299  			}
	1300  			want("abc", nil)
	1301  			want("", nil)
	1302  			want("def", nil)
	1303  			want("", io.EOF)
	1304  		})
	1305  	}
	1306  }
	1307  
	1308  func TestReaderReset(t *testing.T) {
	1309  	r := NewReader(strings.NewReader("foo foo"))
	1310  	buf := make([]byte, 3)
	1311  	r.Read(buf)
	1312  	if string(buf) != "foo" {
	1313  		t.Errorf("buf = %q; want foo", buf)
	1314  	}
	1315  	r.Reset(strings.NewReader("bar bar"))
	1316  	all, err := io.ReadAll(r)
	1317  	if err != nil {
	1318  		t.Fatal(err)
	1319  	}
	1320  	if string(all) != "bar bar" {
	1321  		t.Errorf("ReadAll = %q; want bar bar", all)
	1322  	}
	1323  }
	1324  
	1325  func TestWriterReset(t *testing.T) {
	1326  	var buf1, buf2 bytes.Buffer
	1327  	w := NewWriter(&buf1)
	1328  	w.WriteString("foo")
	1329  	w.Reset(&buf2) // and not flushed
	1330  	w.WriteString("bar")
	1331  	w.Flush()
	1332  	if buf1.String() != "" {
	1333  		t.Errorf("buf1 = %q; want empty", buf1.String())
	1334  	}
	1335  	if buf2.String() != "bar" {
	1336  		t.Errorf("buf2 = %q; want bar", buf2.String())
	1337  	}
	1338  }
	1339  
	1340  func TestReaderDiscard(t *testing.T) {
	1341  	tests := []struct {
	1342  		name		 string
	1343  		r				io.Reader
	1344  		bufSize	int // 0 means 16
	1345  		peekSize int
	1346  
	1347  		n int // input to Discard
	1348  
	1349  		want		int	 // from Discard
	1350  		wantErr error // from Discard
	1351  
	1352  		wantBuffered int
	1353  	}{
	1354  		{
	1355  			name:				 "normal case",
	1356  			r:						strings.NewReader("abcdefghijklmnopqrstuvwxyz"),
	1357  			peekSize:		 16,
	1358  			n:						6,
	1359  			want:				 6,
	1360  			wantBuffered: 10,
	1361  		},
	1362  		{
	1363  			name:				 "discard causing read",
	1364  			r:						strings.NewReader("abcdefghijklmnopqrstuvwxyz"),
	1365  			n:						6,
	1366  			want:				 6,
	1367  			wantBuffered: 10,
	1368  		},
	1369  		{
	1370  			name:				 "discard all without peek",
	1371  			r:						strings.NewReader("abcdefghijklmnopqrstuvwxyz"),
	1372  			n:						26,
	1373  			want:				 26,
	1374  			wantBuffered: 0,
	1375  		},
	1376  		{
	1377  			name:				 "discard more than end",
	1378  			r:						strings.NewReader("abcdefghijklmnopqrstuvwxyz"),
	1379  			n:						27,
	1380  			want:				 26,
	1381  			wantErr:			io.EOF,
	1382  			wantBuffered: 0,
	1383  		},
	1384  		// Any error from filling shouldn't show up until we
	1385  		// get past the valid bytes. Here we return we return 5 valid bytes at the same time
	1386  		// as an error, but test that we don't see the error from Discard.
	1387  		{
	1388  			name: "fill error, discard less",
	1389  			r: newScriptedReader(func(p []byte) (n int, err error) {
	1390  				if len(p) < 5 {
	1391  					panic("unexpected small read")
	1392  				}
	1393  				return 5, errors.New("5-then-error")
	1394  			}),
	1395  			n:						4,
	1396  			want:				 4,
	1397  			wantErr:			nil,
	1398  			wantBuffered: 1,
	1399  		},
	1400  		{
	1401  			name: "fill error, discard equal",
	1402  			r: newScriptedReader(func(p []byte) (n int, err error) {
	1403  				if len(p) < 5 {
	1404  					panic("unexpected small read")
	1405  				}
	1406  				return 5, errors.New("5-then-error")
	1407  			}),
	1408  			n:						5,
	1409  			want:				 5,
	1410  			wantErr:			nil,
	1411  			wantBuffered: 0,
	1412  		},
	1413  		{
	1414  			name: "fill error, discard more",
	1415  			r: newScriptedReader(func(p []byte) (n int, err error) {
	1416  				if len(p) < 5 {
	1417  					panic("unexpected small read")
	1418  				}
	1419  				return 5, errors.New("5-then-error")
	1420  			}),
	1421  			n:						6,
	1422  			want:				 5,
	1423  			wantErr:			errors.New("5-then-error"),
	1424  			wantBuffered: 0,
	1425  		},
	1426  		// Discard of 0 shouldn't cause a read:
	1427  		{
	1428  			name:				 "discard zero",
	1429  			r:						newScriptedReader(), // will panic on Read
	1430  			n:						0,
	1431  			want:				 0,
	1432  			wantErr:			nil,
	1433  			wantBuffered: 0,
	1434  		},
	1435  		{
	1436  			name:				 "discard negative",
	1437  			r:						newScriptedReader(), // will panic on Read
	1438  			n:						-1,
	1439  			want:				 0,
	1440  			wantErr:			ErrNegativeCount,
	1441  			wantBuffered: 0,
	1442  		},
	1443  	}
	1444  	for _, tt := range tests {
	1445  		br := NewReaderSize(tt.r, tt.bufSize)
	1446  		if tt.peekSize > 0 {
	1447  			peekBuf, err := br.Peek(tt.peekSize)
	1448  			if err != nil {
	1449  				t.Errorf("%s: Peek(%d): %v", tt.name, tt.peekSize, err)
	1450  				continue
	1451  			}
	1452  			if len(peekBuf) != tt.peekSize {
	1453  				t.Errorf("%s: len(Peek(%d)) = %v; want %v", tt.name, tt.peekSize, len(peekBuf), tt.peekSize)
	1454  				continue
	1455  			}
	1456  		}
	1457  		discarded, err := br.Discard(tt.n)
	1458  		if ge, we := fmt.Sprint(err), fmt.Sprint(tt.wantErr); discarded != tt.want || ge != we {
	1459  			t.Errorf("%s: Discard(%d) = (%v, %v); want (%v, %v)", tt.name, tt.n, discarded, ge, tt.want, we)
	1460  			continue
	1461  		}
	1462  		if bn := br.Buffered(); bn != tt.wantBuffered {
	1463  			t.Errorf("%s: after Discard, Buffered = %d; want %d", tt.name, bn, tt.wantBuffered)
	1464  		}
	1465  	}
	1466  
	1467  }
	1468  
	1469  func TestReaderSize(t *testing.T) {
	1470  	if got, want := NewReader(nil).Size(), DefaultBufSize; got != want {
	1471  		t.Errorf("NewReader's Reader.Size = %d; want %d", got, want)
	1472  	}
	1473  	if got, want := NewReaderSize(nil, 1234).Size(), 1234; got != want {
	1474  		t.Errorf("NewReaderSize's Reader.Size = %d; want %d", got, want)
	1475  	}
	1476  }
	1477  
	1478  func TestWriterSize(t *testing.T) {
	1479  	if got, want := NewWriter(nil).Size(), DefaultBufSize; got != want {
	1480  		t.Errorf("NewWriter's Writer.Size = %d; want %d", got, want)
	1481  	}
	1482  	if got, want := NewWriterSize(nil, 1234).Size(), 1234; got != want {
	1483  		t.Errorf("NewWriterSize's Writer.Size = %d; want %d", got, want)
	1484  	}
	1485  }
	1486  
	1487  // An onlyReader only implements io.Reader, no matter what other methods the underlying implementation may have.
	1488  type onlyReader struct {
	1489  	io.Reader
	1490  }
	1491  
	1492  // An onlyWriter only implements io.Writer, no matter what other methods the underlying implementation may have.
	1493  type onlyWriter struct {
	1494  	io.Writer
	1495  }
	1496  
	1497  // A scriptedReader is an io.Reader that executes its steps sequentially.
	1498  type scriptedReader []func(p []byte) (n int, err error)
	1499  
	1500  func (sr *scriptedReader) Read(p []byte) (n int, err error) {
	1501  	if len(*sr) == 0 {
	1502  		panic("too many Read calls on scripted Reader. No steps remain.")
	1503  	}
	1504  	step := (*sr)[0]
	1505  	*sr = (*sr)[1:]
	1506  	return step(p)
	1507  }
	1508  
	1509  func newScriptedReader(steps ...func(p []byte) (n int, err error)) io.Reader {
	1510  	sr := scriptedReader(steps)
	1511  	return &sr
	1512  }
	1513  
	1514  // eofReader returns the number of bytes read and io.EOF for the read that consumes the last of the content.
	1515  type eofReader struct {
	1516  	buf []byte
	1517  }
	1518  
	1519  func (r *eofReader) Read(p []byte) (int, error) {
	1520  	read := copy(p, r.buf)
	1521  	r.buf = r.buf[read:]
	1522  
	1523  	switch read {
	1524  	case 0, len(r.buf):
	1525  		// As allowed in the documentation, this will return io.EOF
	1526  		// in the same call that consumes the last of the data.
	1527  		// https://godoc.org/io#Reader
	1528  		return read, io.EOF
	1529  	}
	1530  
	1531  	return read, nil
	1532  }
	1533  
	1534  func TestPartialReadEOF(t *testing.T) {
	1535  	src := make([]byte, 10)
	1536  	eofR := &eofReader{buf: src}
	1537  	r := NewReader(eofR)
	1538  
	1539  	// Start by reading 5 of the 10 available bytes.
	1540  	dest := make([]byte, 5)
	1541  	read, err := r.Read(dest)
	1542  	if err != nil {
	1543  		t.Fatalf("unexpected error: %v", err)
	1544  	}
	1545  	if n := len(dest); read != n {
	1546  		t.Fatalf("read %d bytes; wanted %d bytes", read, n)
	1547  	}
	1548  
	1549  	// The Reader should have buffered all the content from the io.Reader.
	1550  	if n := len(eofR.buf); n != 0 {
	1551  		t.Fatalf("got %d bytes left in bufio.Reader source; want 0 bytes", n)
	1552  	}
	1553  	// To prove the point, check that there are still 5 bytes available to read.
	1554  	if n := r.Buffered(); n != 5 {
	1555  		t.Fatalf("got %d bytes buffered in bufio.Reader; want 5 bytes", n)
	1556  	}
	1557  
	1558  	// This is the second read of 0 bytes.
	1559  	read, err = r.Read([]byte{})
	1560  	if err != nil {
	1561  		t.Fatalf("unexpected error: %v", err)
	1562  	}
	1563  	if read != 0 {
	1564  		t.Fatalf("read %d bytes; want 0 bytes", read)
	1565  	}
	1566  }
	1567  
	1568  type writerWithReadFromError struct{}
	1569  
	1570  func (w writerWithReadFromError) ReadFrom(r io.Reader) (int64, error) {
	1571  	return 0, errors.New("writerWithReadFromError error")
	1572  }
	1573  
	1574  func (w writerWithReadFromError) Write(b []byte) (n int, err error) {
	1575  	return 10, nil
	1576  }
	1577  
	1578  func TestWriterReadFromMustSetUnderlyingError(t *testing.T) {
	1579  	var wr = NewWriter(writerWithReadFromError{})
	1580  	if _, err := wr.ReadFrom(strings.NewReader("test2")); err == nil {
	1581  		t.Fatal("expected ReadFrom returns error, got nil")
	1582  	}
	1583  	if _, err := wr.Write([]byte("123")); err == nil {
	1584  		t.Fatal("expected Write returns error, got nil")
	1585  	}
	1586  }
	1587  
	1588  type writeErrorOnlyWriter struct{}
	1589  
	1590  func (w writeErrorOnlyWriter) Write(p []byte) (n int, err error) {
	1591  	return 0, errors.New("writeErrorOnlyWriter error")
	1592  }
	1593  
	1594  // Ensure that previous Write errors are immediately returned
	1595  // on any ReadFrom. See golang.org/issue/35194.
	1596  func TestWriterReadFromMustReturnUnderlyingError(t *testing.T) {
	1597  	var wr = NewWriter(writeErrorOnlyWriter{})
	1598  	s := "test1"
	1599  	wantBuffered := len(s)
	1600  	if _, err := wr.WriteString(s); err != nil {
	1601  		t.Fatalf("unexpected error: %v", err)
	1602  	}
	1603  	if err := wr.Flush(); err == nil {
	1604  		t.Error("expected flush error, got nil")
	1605  	}
	1606  	if _, err := wr.ReadFrom(strings.NewReader("test2")); err == nil {
	1607  		t.Fatal("expected error, got nil")
	1608  	}
	1609  	if buffered := wr.Buffered(); buffered != wantBuffered {
	1610  		t.Fatalf("Buffered = %v; want %v", buffered, wantBuffered)
	1611  	}
	1612  }
	1613  
	1614  func BenchmarkReaderCopyOptimal(b *testing.B) {
	1615  	// Optimal case is where the underlying reader implements io.WriterTo
	1616  	srcBuf := bytes.NewBuffer(make([]byte, 8192))
	1617  	src := NewReader(srcBuf)
	1618  	dstBuf := new(bytes.Buffer)
	1619  	dst := onlyWriter{dstBuf}
	1620  	for i := 0; i < b.N; i++ {
	1621  		srcBuf.Reset()
	1622  		src.Reset(srcBuf)
	1623  		dstBuf.Reset()
	1624  		io.Copy(dst, src)
	1625  	}
	1626  }
	1627  
	1628  func BenchmarkReaderCopyUnoptimal(b *testing.B) {
	1629  	// Unoptimal case is where the underlying reader doesn't implement io.WriterTo
	1630  	srcBuf := bytes.NewBuffer(make([]byte, 8192))
	1631  	src := NewReader(onlyReader{srcBuf})
	1632  	dstBuf := new(bytes.Buffer)
	1633  	dst := onlyWriter{dstBuf}
	1634  	for i := 0; i < b.N; i++ {
	1635  		srcBuf.Reset()
	1636  		src.Reset(onlyReader{srcBuf})
	1637  		dstBuf.Reset()
	1638  		io.Copy(dst, src)
	1639  	}
	1640  }
	1641  
	1642  func BenchmarkReaderCopyNoWriteTo(b *testing.B) {
	1643  	srcBuf := bytes.NewBuffer(make([]byte, 8192))
	1644  	srcReader := NewReader(srcBuf)
	1645  	src := onlyReader{srcReader}
	1646  	dstBuf := new(bytes.Buffer)
	1647  	dst := onlyWriter{dstBuf}
	1648  	for i := 0; i < b.N; i++ {
	1649  		srcBuf.Reset()
	1650  		srcReader.Reset(srcBuf)
	1651  		dstBuf.Reset()
	1652  		io.Copy(dst, src)
	1653  	}
	1654  }
	1655  
	1656  func BenchmarkReaderWriteToOptimal(b *testing.B) {
	1657  	const bufSize = 16 << 10
	1658  	buf := make([]byte, bufSize)
	1659  	r := bytes.NewReader(buf)
	1660  	srcReader := NewReaderSize(onlyReader{r}, 1<<10)
	1661  	if _, ok := io.Discard.(io.ReaderFrom); !ok {
	1662  		b.Fatal("io.Discard doesn't support ReaderFrom")
	1663  	}
	1664  	for i := 0; i < b.N; i++ {
	1665  		r.Seek(0, io.SeekStart)
	1666  		srcReader.Reset(onlyReader{r})
	1667  		n, err := srcReader.WriteTo(io.Discard)
	1668  		if err != nil {
	1669  			b.Fatal(err)
	1670  		}
	1671  		if n != bufSize {
	1672  			b.Fatalf("n = %d; want %d", n, bufSize)
	1673  		}
	1674  	}
	1675  }
	1676  
	1677  func BenchmarkReaderReadString(b *testing.B) {
	1678  	r := strings.NewReader("			 foo			 foo				42				42				42				42				42				42				42				42			 4.2			 4.2			 4.2			 4.2\n")
	1679  	buf := NewReader(r)
	1680  	b.ReportAllocs()
	1681  	for i := 0; i < b.N; i++ {
	1682  		r.Seek(0, io.SeekStart)
	1683  		buf.Reset(r)
	1684  
	1685  		_, err := buf.ReadString('\n')
	1686  		if err != nil {
	1687  			b.Fatal(err)
	1688  		}
	1689  	}
	1690  }
	1691  
	1692  func BenchmarkWriterCopyOptimal(b *testing.B) {
	1693  	// Optimal case is where the underlying writer implements io.ReaderFrom
	1694  	srcBuf := bytes.NewBuffer(make([]byte, 8192))
	1695  	src := onlyReader{srcBuf}
	1696  	dstBuf := new(bytes.Buffer)
	1697  	dst := NewWriter(dstBuf)
	1698  	for i := 0; i < b.N; i++ {
	1699  		srcBuf.Reset()
	1700  		dstBuf.Reset()
	1701  		dst.Reset(dstBuf)
	1702  		io.Copy(dst, src)
	1703  	}
	1704  }
	1705  
	1706  func BenchmarkWriterCopyUnoptimal(b *testing.B) {
	1707  	srcBuf := bytes.NewBuffer(make([]byte, 8192))
	1708  	src := onlyReader{srcBuf}
	1709  	dstBuf := new(bytes.Buffer)
	1710  	dst := NewWriter(onlyWriter{dstBuf})
	1711  	for i := 0; i < b.N; i++ {
	1712  		srcBuf.Reset()
	1713  		dstBuf.Reset()
	1714  		dst.Reset(onlyWriter{dstBuf})
	1715  		io.Copy(dst, src)
	1716  	}
	1717  }
	1718  
	1719  func BenchmarkWriterCopyNoReadFrom(b *testing.B) {
	1720  	srcBuf := bytes.NewBuffer(make([]byte, 8192))
	1721  	src := onlyReader{srcBuf}
	1722  	dstBuf := new(bytes.Buffer)
	1723  	dstWriter := NewWriter(dstBuf)
	1724  	dst := onlyWriter{dstWriter}
	1725  	for i := 0; i < b.N; i++ {
	1726  		srcBuf.Reset()
	1727  		dstBuf.Reset()
	1728  		dstWriter.Reset(dstBuf)
	1729  		io.Copy(dst, src)
	1730  	}
	1731  }
	1732  
	1733  func BenchmarkReaderEmpty(b *testing.B) {
	1734  	b.ReportAllocs()
	1735  	str := strings.Repeat("x", 16<<10)
	1736  	for i := 0; i < b.N; i++ {
	1737  		br := NewReader(strings.NewReader(str))
	1738  		n, err := io.Copy(io.Discard, br)
	1739  		if err != nil {
	1740  			b.Fatal(err)
	1741  		}
	1742  		if n != int64(len(str)) {
	1743  			b.Fatal("wrong length")
	1744  		}
	1745  	}
	1746  }
	1747  
	1748  func BenchmarkWriterEmpty(b *testing.B) {
	1749  	b.ReportAllocs()
	1750  	str := strings.Repeat("x", 1<<10)
	1751  	bs := []byte(str)
	1752  	for i := 0; i < b.N; i++ {
	1753  		bw := NewWriter(io.Discard)
	1754  		bw.Flush()
	1755  		bw.WriteByte('a')
	1756  		bw.Flush()
	1757  		bw.WriteRune('B')
	1758  		bw.Flush()
	1759  		bw.Write(bs)
	1760  		bw.Flush()
	1761  		bw.WriteString(str)
	1762  		bw.Flush()
	1763  	}
	1764  }
	1765  
	1766  func BenchmarkWriterFlush(b *testing.B) {
	1767  	b.ReportAllocs()
	1768  	bw := NewWriter(io.Discard)
	1769  	str := strings.Repeat("x", 50)
	1770  	for i := 0; i < b.N; i++ {
	1771  		bw.WriteString(str)
	1772  		bw.Flush()
	1773  	}
	1774  }
	1775  

View as plain text