libgo/go/bufio/bufio_test.go

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