github.com/x04/go/src@v0.0.0-20200202162449-3d481ceb3525/bufio/bufio_test.go (about) 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 . "github.com/x04/go/src/bufio" 9 "github.com/x04/go/src/bytes" 10 "github.com/x04/go/src/errors" 11 "github.com/x04/go/src/fmt" 12 "github.com/x04/go/src/io" 13 "github.com/x04/go/src/io/ioutil" 14 "github.com/x04/go/src/strings" 15 "github.com/x04/go/src/testing" 16 "github.com/x04/go/src/testing/iotest" 17 "github.com/x04/go/src/time" 18 "github.com/x04/go/src/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 }