main/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         "fmt"
  11         "io"
  12         "io/ioutil"
  13         "strings"
  14         "testing"
  15         "testing/iotest"
  16         "unicode/utf8"
  17 )
  18
  19 // Reads from a reader and rot13s the result.
  20 type rot13Reader struct {
  21         r io.Reader
  22 }
  23
  24 func newRot13Reader(r io.Reader) *rot13Reader {
  25         r13 := new(rot13Reader)
  26         r13.r = r
  27         return r13
  28 }
  29
  30 func (r13 *rot13Reader) Read(p []byte) (int, error) {
  31         n, err := r13.r.Read(p)
  32         if err != nil {
  33                 return n, err
  34         }
  35         for i := 0; i < n; i++ {
  36                 c := p[i] | 0x20 // lowercase byte
  37                 if 'a' <= c && c <= 'm' {
  38                         p[i] += 13
  39                 } else if 'n' <= c && c <= 'z' {
  40                         p[i] -= 13
  41                 }
  42         }
  43         return n, nil
  44 }
  45
  46 // Call ReadByte to accumulate the text of a file
  47 func readBytes(buf *Reader) string {
  48         var b [1000]byte
  49         nb := 0
  50         for {
  51                 c, err := buf.ReadByte()
  52                 if err == io.EOF {
  53                         break
  54                 }
  55                 if err == nil {
  56                         b[nb] = c
  57                         nb++
  58                 } else if err != iotest.ErrTimeout {
  59                         panic("Data: " + err.Error())
  60                 }
  61         }
  62         return string(b[0:nb])
  63 }
  64
  65 func TestReaderSimple(t *testing.T) {
  66         data := "hello world"
  67         b := NewReader(bytes.NewBufferString(data))
  68         if s := readBytes(b); s != "hello world" {
  69                 t.Errorf("simple hello world test failed: got %q", s)
  70         }
  71
  72         b = NewReader(newRot13Reader(bytes.NewBufferString(data)))
  73         if s := readBytes(b); s != "uryyb jbeyq" {
  74                 t.Errorf("rot13 hello world test failed: got %q", s)
  75         }
  76 }
  77
  78 type readMaker struct {
  79         name string
  80         fn   func(io.Reader) io.Reader
  81 }
  82
  83 var readMakers = []readMaker{
  84         {"full", func(r io.Reader) io.Reader { return r }},
  85         {"byte", iotest.OneByteReader},
  86         {"half", iotest.HalfReader},
  87         {"data+err", iotest.DataErrReader},
  88         {"timeout", iotest.TimeoutReader},
  89 }
  90
  91 // Call ReadString (which ends up calling everything else)
  92 // to accumulate the text of a file.
  93 func readLines(b *Reader) string {
  94         s := ""
  95         for {
  96                 s1, err := b.ReadString('\n')
  97                 if err == io.EOF {
  98                         break
  99                 }
 100                 if err != nil && err != iotest.ErrTimeout {
 101                         panic("GetLines: " + err.Error())
 102                 }
 103                 s += s1
 104         }
 105         return s
 106 }
 107
 108 // Call Read to accumulate the text of a file
 109 func reads(buf *Reader, m int) string {
 110         var b [1000]byte
 111         nb := 0
 112         for {
 113                 n, err := buf.Read(b[nb : nb+m])
 114                 nb += n
 115                 if err == io.EOF {
 116                         break
 117                 }
 118         }
 119         return string(b[0:nb])
 120 }
 121
 122 type bufReader struct {
 123         name string
 124         fn   func(*Reader) string
 125 }
 126
 127 var bufreaders = []bufReader{
 128         {"1", func(b *Reader) string { return reads(b, 1) }},
 129         {"2", func(b *Reader) string { return reads(b, 2) }},
 130         {"3", func(b *Reader) string { return reads(b, 3) }},
 131         {"4", func(b *Reader) string { return reads(b, 4) }},
 132         {"5", func(b *Reader) string { return reads(b, 5) }},
 133         {"7", func(b *Reader) string { return reads(b, 7) }},
 134         {"bytes", readBytes},
 135         {"lines", readLines},
 136 }
 137
 138 const minReadBufferSize = 16
 139
 140 var bufsizes = []int{
 141         minReadBufferSize, 23, 32, 46, 64, 93, 128, 1024, 4096,
 142 }
 143
 144 func TestReader(t *testing.T) {
 145         var texts [31]string
 146         str := ""
 147         all := ""
 148         for i := 0; i < len(texts)-1; i++ {
 149                 texts[i] = str + "\n"
 150                 all += texts[i]
 151                 str += string(i%26 + 'a')
 152         }
 153         texts[len(texts)-1] = all
 154
 155         for h := 0; h < len(texts); h++ {
 156                 text := texts[h]
 157                 for i := 0; i < len(readMakers); i++ {
 158                         for j := 0; j < len(bufreaders); j++ {
 159                                 for k := 0; k < len(bufsizes); k++ {
 160                                         readmaker := readMakers[i]
 161                                         bufreader := bufreaders[j]
 162                                         bufsize := bufsizes[k]
 163                                         read := readmaker.fn(bytes.NewBufferString(text))
 164                                         buf := NewReaderSize(read, bufsize)
 165                                         s := bufreader.fn(buf)
 166                                         if s != text {
 167                                                 t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
 168                                                         readmaker.name, bufreader.name, bufsize, text, s)
 169                                         }
 170                                 }
 171                         }
 172                 }
 173         }
 174 }
 175
 176 // A StringReader delivers its data one string segment at a time via Read.
 177 type StringReader struct {
 178         data []string
 179         step int
 180 }
 181
 182 func (r *StringReader) Read(p []byte) (n int, err error) {
 183         if r.step < len(r.data) {
 184                 s := r.data[r.step]
 185                 n = copy(p, s)
 186                 r.step++
 187         } else {
 188                 err = io.EOF
 189         }
 190         return
 191 }
 192
 193 func readRuneSegments(t *testing.T, segments []string) {
 194         got := ""
 195         want := strings.Join(segments, "")
 196         r := NewReader(&StringReader{data: segments})
 197         for {
 198                 r, _, err := r.ReadRune()
 199                 if err != nil {
 200                         if err != io.EOF {
 201                                 return
 202                         }
 203                         break
 204                 }
 205                 got += string(r)
 206         }
 207         if got != want {
 208                 t.Errorf("segments=%v got=%s want=%s", segments, got, want)
 209         }
 210 }
 211
 212 var segmentList = [][]string{
 213         {},
 214         {""},
 215         {"日", "本語"},
 216         {"\u65e5", "\u672c", "\u8a9e"},
 217         {"\U000065e5", "\U0000672c", "\U00008a9e"},
 218         {"\xe6", "\x97\xa5\xe6", "\x9c\xac\xe8\xaa\x9e"},
 219         {"Hello", ", ", "World", "!"},
 220         {"Hello", ", ", "", "World", "!"},
 221 }
 222
 223 func TestReadRune(t *testing.T) {
 224         for _, s := range segmentList {
 225                 readRuneSegments(t, s)
 226         }
 227 }
 228
 229 func TestUnreadRune(t *testing.T) {
 230         got := ""
 231         segments := []string{"Hello, world:", "日本語"}
 232         data := strings.Join(segments, "")
 233         r := NewReader(&StringReader{data: segments})
 234         // Normal execution.
 235         for {
 236                 r1, _, err := r.ReadRune()
 237                 if err != nil {
 238                         if err != io.EOF {
 239                                 t.Error("unexpected EOF")
 240                         }
 241                         break
 242                 }
 243                 got += string(r1)
 244                 // Put it back and read it again
 245                 if err = r.UnreadRune(); err != nil {
 246                         t.Error("unexpected error on UnreadRune:", err)
 247                 }
 248                 r2, _, err := r.ReadRune()
 249                 if err != nil {
 250                         t.Error("unexpected error reading after unreading:", err)
 251                 }
 252                 if r1 != r2 {
 253                         t.Errorf("incorrect rune after unread: got %c wanted %c", r1, r2)
 254                 }
 255         }
 256         if got != data {
 257                 t.Errorf("want=%q got=%q", data, got)
 258         }
 259 }
 260
 261 // Test that UnreadRune fails if the preceding operation was not a ReadRune.
 262 func TestUnreadRuneError(t *testing.T) {
 263         buf := make([]byte, 3) // All runes in this test are 3 bytes long
 264         r := NewReader(&StringReader{data: []string{"日本語日本語日本語"}})
 265         if r.UnreadRune() == nil {
 266                 t.Error("expected error on UnreadRune from fresh buffer")
 267         }
 268         _, _, err := r.ReadRune()
 269         if err != nil {
 270                 t.Error("unexpected error on ReadRune (1):", err)
 271         }
 272         if err = r.UnreadRune(); err != nil {
 273                 t.Error("unexpected error on UnreadRune (1):", err)
 274         }
 275         if r.UnreadRune() == nil {
 276                 t.Error("expected error after UnreadRune (1)")
 277         }
 278         // Test error after Read.
 279         _, _, err = r.ReadRune() // reset state
 280         if err != nil {
 281                 t.Error("unexpected error on ReadRune (2):", err)
 282         }
 283         _, err = r.Read(buf)
 284         if err != nil {
 285                 t.Error("unexpected error on Read (2):", err)
 286         }
 287         if r.UnreadRune() == nil {
 288                 t.Error("expected error after Read (2)")
 289         }
 290         // Test error after ReadByte.
 291         _, _, err = r.ReadRune() // reset state
 292         if err != nil {
 293                 t.Error("unexpected error on ReadRune (2):", err)
 294         }
 295         for _ = range buf {
 296                 _, err = r.ReadByte()
 297                 if err != nil {
 298                         t.Error("unexpected error on ReadByte (2):", err)
 299                 }
 300         }
 301         if r.UnreadRune() == nil {
 302                 t.Error("expected error after ReadByte")
 303         }
 304         // Test error after UnreadByte.
 305         _, _, err = r.ReadRune() // reset state
 306         if err != nil {
 307                 t.Error("unexpected error on ReadRune (3):", err)
 308         }
 309         _, err = r.ReadByte()
 310         if err != nil {
 311                 t.Error("unexpected error on ReadByte (3):", err)
 312         }
 313         err = r.UnreadByte()
 314         if err != nil {
 315                 t.Error("unexpected error on UnreadByte (3):", err)
 316         }
 317         if r.UnreadRune() == nil {
 318                 t.Error("expected error after UnreadByte (3)")
 319         }
 320 }
 321
 322 func TestUnreadRuneAtEOF(t *testing.T) {
 323         // UnreadRune/ReadRune should error at EOF (was a bug; used to panic)
 324         r := NewReader(strings.NewReader("x"))
 325         r.ReadRune()
 326         r.ReadRune()
 327         r.UnreadRune()
 328         _, _, err := r.ReadRune()
 329         if err == nil {
 330                 t.Error("expected error at EOF")
 331         } else if err != io.EOF {
 332                 t.Error("expected EOF; got", err)
 333         }
 334 }
 335
 336 func TestReadWriteRune(t *testing.T) {
 337         const NRune = 1000
 338         byteBuf := new(bytes.Buffer)
 339         w := NewWriter(byteBuf)
 340         // Write the runes out using WriteRune
 341         buf := make([]byte, utf8.UTFMax)
 342         for r := rune(0); r < NRune; r++ {
 343                 size := utf8.EncodeRune(buf, r)
 344                 nbytes, err := w.WriteRune(r)
 345                 if err != nil {
 346                         t.Fatalf("WriteRune(0x%x) error: %s", r, err)
 347                 }
 348                 if nbytes != size {
 349                         t.Fatalf("WriteRune(0x%x) expected %d, got %d", r, size, nbytes)
 350                 }
 351         }
 352         w.Flush()
 353
 354         r := NewReader(byteBuf)
 355         // Read them back with ReadRune
 356         for r1 := rune(0); r1 < NRune; r1++ {
 357                 size := utf8.EncodeRune(buf, r1)
 358                 nr, nbytes, err := r.ReadRune()
 359                 if nr != r1 || nbytes != size || err != nil {
 360                         t.Fatalf("ReadRune(0x%x) got 0x%x,%d not 0x%x,%d (err=%s)", r1, nr, nbytes, r1, size, err)
 361                 }
 362         }
 363 }
 364
 365 func TestWriter(t *testing.T) {
 366         var data [8192]byte
 367
 368         for i := 0; i < len(data); i++ {
 369                 data[i] = byte(' ' + i%('~'-' '))
 370         }
 371         w := new(bytes.Buffer)
 372         for i := 0; i < len(bufsizes); i++ {
 373                 for j := 0; j < len(bufsizes); j++ {
 374                         nwrite := bufsizes[i]
 375                         bs := bufsizes[j]
 376
 377                         // Write nwrite bytes using buffer size bs.
 378                         // Check that the right amount makes it out
 379                         // and that the data is correct.
 380
 381                         w.Reset()
 382                         buf := NewWriterSize(w, bs)
 383                         context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs)
 384                         n, e1 := buf.Write(data[0:nwrite])
 385                         if e1 != nil || n != nwrite {
 386                                 t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1)
 387                                 continue
 388                         }
 389                         if e := buf.Flush(); e != nil {
 390                                 t.Errorf("%s: buf.Flush = %v", context, e)
 391                         }
 392
 393                         written := w.Bytes()
 394                         if len(written) != nwrite {
 395                                 t.Errorf("%s: %d bytes written", context, len(written))
 396                         }
 397                         for l := 0; l < len(written); l++ {
 398                                 if written[i] != data[i] {
 399                                         t.Errorf("wrong bytes written")
 400                                         t.Errorf("want=%q", data[0:len(written)])
 401                                         t.Errorf("have=%q", written)
 402                                 }
 403                         }
 404                 }
 405         }
 406 }
 407
 408 // Check that write errors are returned properly.
 409
 410 type errorWriterTest struct {
 411         n, m   int
 412         err    error
 413         expect error
 414 }
 415
 416 func (w errorWriterTest) Write(p []byte) (int, error) {
 417         return len(p) * w.n / w.m, w.err
 418 }
 419
 420 var errorWriterTests = []errorWriterTest{
 421         {0, 1, nil, io.ErrShortWrite},
 422         {1, 2, nil, io.ErrShortWrite},
 423         {1, 1, nil, nil},
 424         {0, 1, io.ErrClosedPipe, io.ErrClosedPipe},
 425         {1, 2, io.ErrClosedPipe, io.ErrClosedPipe},
 426         {1, 1, io.ErrClosedPipe, io.ErrClosedPipe},
 427 }
 428
 429 func TestWriteErrors(t *testing.T) {
 430         for _, w := range errorWriterTests {
 431                 buf := NewWriter(w)
 432                 _, e := buf.Write([]byte("hello world"))
 433                 if e != nil {
 434                         t.Errorf("Write hello to %v: %v", w, e)
 435                         continue
 436                 }
 437                 e = buf.Flush()
 438                 if e != w.expect {
 439                         t.Errorf("Flush %v: got %v, wanted %v", w, e, w.expect)
 440                 }
 441         }
 442 }
 443
 444 func TestNewReaderSizeIdempotent(t *testing.T) {
 445         const BufSize = 1000
 446         b := NewReaderSize(bytes.NewBufferString("hello world"), BufSize)
 447         // Does it recognize itself?
 448         b1 := NewReaderSize(b, BufSize)
 449         if b1 != b {
 450                 t.Error("NewReaderSize did not detect underlying Reader")
 451         }
 452         // Does it wrap if existing buffer is too small?
 453         b2 := NewReaderSize(b, 2*BufSize)
 454         if b2 == b {
 455                 t.Error("NewReaderSize did not enlarge buffer")
 456         }
 457 }
 458
 459 func TestNewWriterSizeIdempotent(t *testing.T) {
 460         const BufSize = 1000
 461         b := NewWriterSize(new(bytes.Buffer), BufSize)
 462         // Does it recognize itself?
 463         b1 := NewWriterSize(b, BufSize)
 464         if b1 != b {
 465                 t.Error("NewWriterSize did not detect underlying Writer")
 466         }
 467         // Does it wrap if existing buffer is too small?
 468         b2 := NewWriterSize(b, 2*BufSize)
 469         if b2 == b {
 470                 t.Error("NewWriterSize did not enlarge buffer")
 471         }
 472 }
 473
 474 func TestWriteString(t *testing.T) {
 475         const BufSize = 8
 476         buf := new(bytes.Buffer)
 477         b := NewWriterSize(buf, BufSize)
 478         b.WriteString("0")                         // easy
 479         b.WriteString("123456")                    // still easy
 480         b.WriteString("7890")                      // easy after flush
 481         b.WriteString("abcdefghijklmnopqrstuvwxy") // hard
 482         b.WriteString("z")
 483         if err := b.Flush(); err != nil {
 484                 t.Error("WriteString", err)
 485         }
 486         s := "01234567890abcdefghijklmnopqrstuvwxyz"
 487         if string(buf.Bytes()) != s {
 488                 t.Errorf("WriteString wants %q gets %q", s, string(buf.Bytes()))
 489         }
 490 }
 491
 492 func TestBufferFull(t *testing.T) {
 493         const longString = "And now, hello, world! It is the time for all good men to come to the aid of their party"
 494         buf := NewReaderSize(strings.NewReader(longString), minReadBufferSize)
 495         line, err := buf.ReadSlice('!')
 496         if string(line) != "And now, hello, " || err != ErrBufferFull {
 497                 t.Errorf("first ReadSlice(,) = %q, %v", line, err)
 498         }
 499         line, err = buf.ReadSlice('!')
 500         if string(line) != "world!" || err != nil {
 501                 t.Errorf("second ReadSlice(,) = %q, %v", line, err)
 502         }
 503 }
 504
 505 func TestPeek(t *testing.T) {
 506         p := make([]byte, 10)
 507         // string is 16 (minReadBufferSize) long.
 508         buf := NewReaderSize(strings.NewReader("abcdefghijklmnop"), minReadBufferSize)
 509         if s, err := buf.Peek(1); string(s) != "a" || err != nil {
 510                 t.Fatalf("want %q got %q, err=%v", "a", string(s), err)
 511         }
 512         if s, err := buf.Peek(4); string(s) != "abcd" || err != nil {
 513                 t.Fatalf("want %q got %q, err=%v", "abcd", string(s), err)
 514         }
 515         if _, err := buf.Peek(32); err != ErrBufferFull {
 516                 t.Fatalf("want ErrBufFull got %v", err)
 517         }
 518         if _, err := buf.Read(p[0:3]); string(p[0:3]) != "abc" || err != nil {
 519                 t.Fatalf("want %q got %q, err=%v", "abc", string(p[0:3]), err)
 520         }
 521         if s, err := buf.Peek(1); string(s) != "d" || err != nil {
 522                 t.Fatalf("want %q got %q, err=%v", "d", string(s), err)
 523         }
 524         if s, err := buf.Peek(2); string(s) != "de" || err != nil {
 525                 t.Fatalf("want %q got %q, err=%v", "de", string(s), err)
 526         }
 527         if _, err := buf.Read(p[0:3]); string(p[0:3]) != "def" || err != nil {
 528                 t.Fatalf("want %q got %q, err=%v", "def", string(p[0:3]), err)
 529         }
 530         if s, err := buf.Peek(4); string(s) != "ghij" || err != nil {
 531                 t.Fatalf("want %q got %q, err=%v", "ghij", string(s), err)
 532         }
 533         if _, err := buf.Read(p[0:]); string(p[0:]) != "ghijklmnop" || err != nil {
 534                 t.Fatalf("want %q got %q, err=%v", "ghijklmnop", string(p[0:minReadBufferSize]), err)
 535         }
 536         if s, err := buf.Peek(0); string(s) != "" || err != nil {
 537                 t.Fatalf("want %q got %q, err=%v", "", string(s), err)
 538         }
 539         if _, err := buf.Peek(1); err != io.EOF {
 540                 t.Fatalf("want EOF got %v", err)
 541         }
 542
 543         // Test for issue 3022, not exposing a reader's error on a successful Peek.
 544         buf = NewReaderSize(dataAndEOFReader("abcd"), 32)
 545         if s, err := buf.Peek(2); string(s) != "ab" || err != nil {
 546                 t.Errorf(`Peek(2) on "abcd", EOF = %q, %v; want "ab", nil`, string(s), err)
 547         }
 548         if s, err := buf.Peek(4); string(s) != "abcd" || err != nil {
 549                 t.Errorf(`Peek(4) on "abcd", EOF = %q, %v; want "abcd", nil`, string(s), err)
 550         }
 551         if n, err := buf.Read(p[0:5]); string(p[0:n]) != "abcd" || err != nil {
 552                 t.Fatalf("Read after peek = %q, %v; want abcd, EOF", p[0:n], err)
 553         }
 554         if n, err := buf.Read(p[0:1]); string(p[0:n]) != "" || err != io.EOF {
 555                 t.Fatalf(`second Read after peek = %q, %v; want "", EOF`, p[0:n], err)
 556         }
 557 }
 558
 559 type dataAndEOFReader string
 560
 561 func (r dataAndEOFReader) Read(p []byte) (int, error) {
 562         return copy(p, r), io.EOF
 563 }
 564
 565 func TestPeekThenUnreadRune(t *testing.T) {
 566         // This sequence used to cause a crash.
 567         r := NewReader(strings.NewReader("x"))
 568         r.ReadRune()
 569         r.Peek(1)
 570         r.UnreadRune()
 571         r.ReadRune() // Used to panic here
 572 }
 573
 574 var testOutput = []byte("0123456789abcdefghijklmnopqrstuvwxy")
 575 var testInput = []byte("012\n345\n678\n9ab\ncde\nfgh\nijk\nlmn\nopq\nrst\nuvw\nxy")
 576 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")
 577
 578 // TestReader wraps a []byte and returns reads of a specific length.
 579 type testReader struct {
 580         data   []byte
 581         stride int
 582 }
 583
 584 func (t *testReader) Read(buf []byte) (n int, err error) {
 585         n = t.stride
 586         if n > len(t.data) {
 587                 n = len(t.data)
 588         }
 589         if n > len(buf) {
 590                 n = len(buf)
 591         }
 592         copy(buf, t.data)
 593         t.data = t.data[n:]
 594         if len(t.data) == 0 {
 595                 err = io.EOF
 596         }
 597         return
 598 }
 599
 600 func testReadLine(t *testing.T, input []byte) {
 601         //for stride := 1; stride < len(input); stride++ {
 602         for stride := 1; stride < 2; stride++ {
 603                 done := 0
 604                 reader := testReader{input, stride}
 605                 l := NewReaderSize(&reader, len(input)+1)
 606                 for {
 607                         line, isPrefix, err := l.ReadLine()
 608                         if len(line) > 0 && err != nil {
 609                                 t.Errorf("ReadLine returned both data and error: %s", err)
 610                         }
 611                         if isPrefix {
 612                                 t.Errorf("ReadLine returned prefix")
 613                         }
 614                         if err != nil {
 615                                 if err != io.EOF {
 616                                         t.Fatalf("Got unknown error: %s", err)
 617                                 }
 618                                 break
 619                         }
 620                         if want := testOutput[done : done+len(line)]; !bytes.Equal(want, line) {
 621                                 t.Errorf("Bad line at stride %d: want: %x got: %x", stride, want, line)
 622                         }
 623                         done += len(line)
 624                 }
 625                 if done != len(testOutput) {
 626                         t.Errorf("ReadLine didn't return everything: got: %d, want: %d (stride: %d)", done, len(testOutput), stride)
 627                 }
 628         }
 629 }
 630
 631 func TestReadLine(t *testing.T) {
 632         testReadLine(t, testInput)
 633         testReadLine(t, testInputrn)
 634 }
 635
 636 func TestLineTooLong(t *testing.T) {
 637         data := make([]byte, 0)
 638         for i := 0; i < minReadBufferSize*5/2; i++ {
 639                 data = append(data, '0'+byte(i%10))
 640         }
 641         buf := bytes.NewBuffer(data)
 642         l := NewReaderSize(buf, minReadBufferSize)
 643         line, isPrefix, err := l.ReadLine()
 644         if !isPrefix || !bytes.Equal(line, data[:minReadBufferSize]) || err != nil {
 645                 t.Errorf("bad result for first line: got %q want %q %v", line, data[:minReadBufferSize], err)
 646         }
 647         data = data[len(line):]
 648         line, isPrefix, err = l.ReadLine()
 649         if !isPrefix || !bytes.Equal(line, data[:minReadBufferSize]) || err != nil {
 650                 t.Errorf("bad result for second line: got %q want %q %v", line, data[:minReadBufferSize], err)
 651         }
 652         data = data[len(line):]
 653         line, isPrefix, err = l.ReadLine()
 654         if isPrefix || !bytes.Equal(line, data[:minReadBufferSize/2]) || err != nil {
 655                 t.Errorf("bad result for third line: got %q want %q %v", line, data[:minReadBufferSize/2], err)
 656         }
 657         line, isPrefix, err = l.ReadLine()
 658         if isPrefix || err == nil {
 659                 t.Errorf("expected no more lines: %x %s", line, err)
 660         }
 661 }
 662
 663 func TestReadAfterLines(t *testing.T) {
 664         line1 := "this is line1"
 665         restData := "this is line2\nthis is line 3\n"
 666         inbuf := bytes.NewBuffer([]byte(line1 + "\n" + restData))
 667         outbuf := new(bytes.Buffer)
 668         maxLineLength := len(line1) + len(restData)/2
 669         l := NewReaderSize(inbuf, maxLineLength)
 670         line, isPrefix, err := l.ReadLine()
 671         if isPrefix || err != nil || string(line) != line1 {
 672                 t.Errorf("bad result for first line: isPrefix=%v err=%v line=%q", isPrefix, err, string(line))
 673         }
 674         n, err := io.Copy(outbuf, l)
 675         if int(n) != len(restData) || err != nil {
 676                 t.Errorf("bad result for Read: n=%d err=%v", n, err)
 677         }
 678         if outbuf.String() != restData {
 679                 t.Errorf("bad result for Read: got %q; expected %q", outbuf.String(), restData)
 680         }
 681 }
 682
 683 func TestReadEmptyBuffer(t *testing.T) {
 684         l := NewReaderSize(new(bytes.Buffer), minReadBufferSize)
 685         line, isPrefix, err := l.ReadLine()
 686         if err != io.EOF {
 687                 t.Errorf("expected EOF from ReadLine, got '%s' %t %s", line, isPrefix, err)
 688         }
 689 }
 690
 691 func TestLinesAfterRead(t *testing.T) {
 692         l := NewReaderSize(bytes.NewBuffer([]byte("foo")), minReadBufferSize)
 693         _, err := ioutil.ReadAll(l)
 694         if err != nil {
 695                 t.Error(err)
 696                 return
 697         }
 698
 699         line, isPrefix, err := l.ReadLine()
 700         if err != io.EOF {
 701                 t.Errorf("expected EOF from ReadLine, got '%s' %t %s", line, isPrefix, err)
 702         }
 703 }
 704
 705 func TestReadLineNonNilLineOrError(t *testing.T) {
 706         r := NewReader(strings.NewReader("line 1\n"))
 707         for i := 0; i < 2; i++ {
 708                 l, _, err := r.ReadLine()
 709                 if l != nil && err != nil {
 710                         t.Fatalf("on line %d/2; ReadLine=%#v, %v; want non-nil line or Error, but not both",
 711                                 i+1, l, err)
 712                 }
 713         }
 714 }
 715
 716 type readLineResult struct {
 717         line     []byte
 718         isPrefix bool
 719         err      error
 720 }
 721
 722 var readLineNewlinesTests = []struct {
 723         input  string
 724         expect []readLineResult
 725 }{
 726         {"012345678901234\r\n012345678901234\r\n", []readLineResult{
 727                 {[]byte("012345678901234"), true, nil},
 728                 {nil, false, nil},
 729                 {[]byte("012345678901234"), true, nil},
 730                 {nil, false, nil},
 731                 {nil, false, io.EOF},
 732         }},
 733         {"0123456789012345\r012345678901234\r", []readLineResult{
 734                 {[]byte("0123456789012345"), true, nil},
 735                 {[]byte("\r012345678901234"), true, nil},
 736                 {[]byte("\r"), false, nil},
 737                 {nil, false, io.EOF},
 738         }},
 739 }
 740
 741 func TestReadLineNewlines(t *testing.T) {
 742         for _, e := range readLineNewlinesTests {
 743                 testReadLineNewlines(t, e.input, e.expect)
 744         }
 745 }
 746
 747 func testReadLineNewlines(t *testing.T, input string, expect []readLineResult) {
 748         b := NewReaderSize(strings.NewReader(input), minReadBufferSize)
 749         for i, e := range expect {
 750                 line, isPrefix, err := b.ReadLine()
 751                 if !bytes.Equal(line, e.line) {
 752                         t.Errorf("%q call %d, line == %q, want %q", input, i, line, e.line)
 753                         return
 754                 }
 755                 if isPrefix != e.isPrefix {
 756                         t.Errorf("%q call %d, isPrefix == %v, want %v", input, i, isPrefix, e.isPrefix)
 757                         return
 758                 }
 759                 if err != e.err {
 760                         t.Errorf("%q call %d, err == %v, want %v", input, i, err, e.err)
 761                         return
 762                 }
 763         }
 764 }
 765
 766 func createTestInput(n int) []byte {
 767         input := make([]byte, n)
 768         for i := range input {
 769                 // 101 and 251 are arbitrary prime numbers.
 770                 // The idea is to create an input sequence
 771                 // which doesn't repeat too frequently.
 772                 input[i] = byte(i % 251)
 773                 if i%101 == 0 {
 774                         input[i] ^= byte(i / 101)
 775                 }
 776         }
 777         return input
 778 }
 779
 780 func TestReaderWriteTo(t *testing.T) {
 781         input := createTestInput(8192)
 782         r := NewReader(onlyReader{bytes.NewBuffer(input)})
 783         w := new(bytes.Buffer)
 784         if n, err := r.WriteTo(w); err != nil || n != int64(len(input)) {
 785                 t.Fatalf("r.WriteTo(w) = %d, %v, want %d, nil", n, err, len(input))
 786         }
 787
 788         for i, val := range w.Bytes() {
 789                 if val != input[i] {
 790                         t.Errorf("after write: out[%d] = %#x, want %#x", i, val, input[i])
 791                 }
 792         }
 793 }
 794
 795 type errorWriterToTest struct {
 796         rn, wn     int
 797         rerr, werr error
 798         expected   error
 799 }
 800
 801 func (r errorWriterToTest) Read(p []byte) (int, error) {
 802         return len(p) * r.rn, r.rerr
 803 }
 804
 805 func (w errorWriterToTest) Write(p []byte) (int, error) {
 806         return len(p) * w.wn, w.werr
 807 }
 808
 809 var errorWriterToTests = []errorWriterToTest{
 810         {1, 0, nil, io.ErrClosedPipe, io.ErrClosedPipe},
 811         {0, 1, io.ErrClosedPipe, nil, io.ErrClosedPipe},
 812         {0, 0, io.ErrUnexpectedEOF, io.ErrClosedPipe, io.ErrClosedPipe},
 813         {0, 1, io.EOF, nil, nil},
 814 }
 815
 816 func TestReaderWriteToErrors(t *testing.T) {
 817         for i, rw := range errorWriterToTests {
 818                 r := NewReader(rw)
 819                 if _, err := r.WriteTo(rw); err != rw.expected {
 820                         t.Errorf("r.WriteTo(errorWriterToTests[%d]) = _, %v, want _,%v", i, err, rw.expected)
 821                 }
 822         }
 823 }
 824
 825 func TestWriterReadFrom(t *testing.T) {
 826         ws := []func(io.Writer) io.Writer{
 827                 func(w io.Writer) io.Writer { return onlyWriter{w} },
 828                 func(w io.Writer) io.Writer { return w },
 829         }
 830
 831         rs := []func(io.Reader) io.Reader{
 832                 iotest.DataErrReader,
 833                 func(r io.Reader) io.Reader { return r },
 834         }
 835
 836         for ri, rfunc := range rs {
 837                 for wi, wfunc := range ws {
 838                         input := createTestInput(8192)
 839                         b := new(bytes.Buffer)
 840                         w := NewWriter(wfunc(b))
 841                         r := rfunc(bytes.NewBuffer(input))
 842                         if n, err := w.ReadFrom(r); err != nil || n != int64(len(input)) {
 843                                 t.Errorf("ws[%d],rs[%d]: w.ReadFrom(r) = %d, %v, want %d, nil", wi, ri, n, err, len(input))
 844                                 continue
 845                         }
 846                         if got, want := b.String(), string(input); got != want {
 847                                 t.Errorf("ws[%d], rs[%d]:\ngot  %q\nwant %q\n", wi, ri, got, want)
 848                         }
 849                 }
 850         }
 851 }
 852
 853 type errorReaderFromTest struct {
 854         rn, wn     int
 855         rerr, werr error
 856         expected   error
 857 }
 858
 859 func (r errorReaderFromTest) Read(p []byte) (int, error) {
 860         return len(p) * r.rn, r.rerr
 861 }
 862
 863 func (w errorReaderFromTest) Write(p []byte) (int, error) {
 864         return len(p) * w.wn, w.werr
 865 }
 866
 867 var errorReaderFromTests = []errorReaderFromTest{
 868         {0, 1, io.EOF, nil, nil},
 869         {1, 1, io.EOF, nil, nil},
 870         {0, 1, io.ErrClosedPipe, nil, io.ErrClosedPipe},
 871         {0, 0, io.ErrClosedPipe, io.ErrShortWrite, io.ErrClosedPipe},
 872         {1, 0, nil, io.ErrShortWrite, io.ErrShortWrite},
 873 }
 874
 875 func TestWriterReadFromErrors(t *testing.T) {
 876         for i, rw := range errorReaderFromTests {
 877                 w := NewWriter(rw)
 878                 if _, err := w.ReadFrom(rw); err != rw.expected {
 879                         t.Errorf("w.ReadFrom(errorReaderFromTests[%d]) = _, %v, want _,%v", i, err, rw.expected)
 880                 }
 881         }
 882 }
 883
 884 // TestWriterReadFromCounts tests that using io.Copy to copy into a
 885 // bufio.Writer does not prematurely flush the buffer. For example, when
 886 // buffering writes to a network socket, excessive network writes should be
 887 // avoided.
 888 func TestWriterReadFromCounts(t *testing.T) {
 889         var w0 writeCountingDiscard
 890         b0 := NewWriterSize(&w0, 1234)
 891         b0.WriteString(strings.Repeat("x", 1000))
 892         if w0 != 0 {
 893                 t.Fatalf("write 1000 'x's: got %d writes, want 0", w0)
 894         }
 895         b0.WriteString(strings.Repeat("x", 200))
 896         if w0 != 0 {
 897                 t.Fatalf("write 1200 'x's: got %d writes, want 0", w0)
 898         }
 899         io.Copy(b0, onlyReader{strings.NewReader(strings.Repeat("x", 30))})
 900         if w0 != 0 {
 901                 t.Fatalf("write 1230 'x's: got %d writes, want 0", w0)
 902         }
 903         io.Copy(b0, onlyReader{strings.NewReader(strings.Repeat("x", 9))})
 904         if w0 != 1 {
 905                 t.Fatalf("write 1239 'x's: got %d writes, want 1", w0)
 906         }
 907
 908         var w1 writeCountingDiscard
 909         b1 := NewWriterSize(&w1, 1234)
 910         b1.WriteString(strings.Repeat("x", 1200))
 911         b1.Flush()
 912         if w1 != 1 {
 913                 t.Fatalf("flush 1200 'x's: got %d writes, want 1", w1)
 914         }
 915         b1.WriteString(strings.Repeat("x", 89))
 916         if w1 != 1 {
 917                 t.Fatalf("write 1200 + 89 'x's: got %d writes, want 1", w1)
 918         }
 919         io.Copy(b1, onlyReader{strings.NewReader(strings.Repeat("x", 700))})
 920         if w1 != 1 {
 921                 t.Fatalf("write 1200 + 789 'x's: got %d writes, want 1", w1)
 922         }
 923         io.Copy(b1, onlyReader{strings.NewReader(strings.Repeat("x", 600))})
 924         if w1 != 2 {
 925                 t.Fatalf("write 1200 + 1389 'x's: got %d writes, want 2", w1)
 926         }
 927         b1.Flush()
 928         if w1 != 3 {
 929                 t.Fatalf("flush 1200 + 1389 'x's: got %d writes, want 3", w1)
 930         }
 931 }
 932
 933 // A writeCountingDiscard is like ioutil.Discard and counts the number of times
 934 // Write is called on it.
 935 type writeCountingDiscard int
 936
 937 func (w *writeCountingDiscard) Write(p []byte) (int, error) {
 938         *w++
 939         return len(p), nil
 940 }
 941
 942 type negativeReader int
 943
 944 func (r *negativeReader) Read([]byte) (int, error) { return -1, nil }
 945
 946 func TestNegativeRead(t *testing.T) {
 947         // should panic with a description pointing at the reader, not at itself.
 948         // (should NOT panic with slice index error, for example.)
 949         b := NewReader(new(negativeReader))
 950         defer func() {
 951                 switch err := recover().(type) {
 952                 case nil:
 953                         t.Fatal("read did not panic")
 954                 case error:
 955                         if !strings.Contains(err.Error(), "reader returned negative count from Read") {
 956                                 t.Fatal("wrong panic: %v", err)
 957                         }
 958                 default:
 959                         t.Fatalf("unexpected panic value: %T(%v)", err, err)
 960                 }
 961         }()
 962         b.Read(make([]byte, 100))
 963 }
 964
 965 // An onlyReader only implements io.Reader, no matter what other methods the underlying implementation may have.
 966 type onlyReader struct {
 967         r io.Reader
 968 }
 969
 970 func (r onlyReader) Read(b []byte) (int, error) {
 971         return r.r.Read(b)
 972 }
 973
 974 // An onlyWriter only implements io.Writer, no matter what other methods the underlying implementation may have.
 975 type onlyWriter struct {
 976         w io.Writer
 977 }
 978
 979 func (w onlyWriter) Write(b []byte) (int, error) {
 980         return w.w.Write(b)
 981 }
 982
 983 func BenchmarkReaderCopyOptimal(b *testing.B) {
 984         // Optimal case is where the underlying reader implements io.WriterTo
 985         for i := 0; i < b.N; i++ {
 986                 b.StopTimer()
 987                 src := NewReader(bytes.NewBuffer(make([]byte, 8192)))
 988                 dst := onlyWriter{new(bytes.Buffer)}
 989                 b.StartTimer()
 990                 io.Copy(dst, src)
 991         }
 992 }
 993
 994 func BenchmarkReaderCopyUnoptimal(b *testing.B) {
 995         // Unoptimal case is where the underlying reader doesn't implement io.WriterTo
 996         for i := 0; i < b.N; i++ {
 997                 b.StopTimer()
 998                 src := NewReader(onlyReader{bytes.NewBuffer(make([]byte, 8192))})
 999                 dst := onlyWriter{new(bytes.Buffer)}
1000                 b.StartTimer()
1001                 io.Copy(dst, src)
1002         }
1003 }
1004
1005 func BenchmarkReaderCopyNoWriteTo(b *testing.B) {
1006         for i := 0; i < b.N; i++ {
1007                 b.StopTimer()
1008                 src := onlyReader{NewReader(bytes.NewBuffer(make([]byte, 8192)))}
1009                 dst := onlyWriter{new(bytes.Buffer)}
1010                 b.StartTimer()
1011                 io.Copy(dst, src)
1012         }
1013 }
1014
1015 func BenchmarkWriterCopyOptimal(b *testing.B) {
1016         // Optimal case is where the underlying writer implements io.ReaderFrom
1017         for i := 0; i < b.N; i++ {
1018                 b.StopTimer()
1019                 src := onlyReader{bytes.NewBuffer(make([]byte, 8192))}
1020                 dst := NewWriter(new(bytes.Buffer))
1021                 b.StartTimer()
1022                 io.Copy(dst, src)
1023         }
1024 }
1025
1026 func BenchmarkWriterCopyUnoptimal(b *testing.B) {
1027         for i := 0; i < b.N; i++ {
1028                 b.StopTimer()
1029                 src := onlyReader{bytes.NewBuffer(make([]byte, 8192))}
1030                 dst := NewWriter(onlyWriter{new(bytes.Buffer)})
1031                 b.StartTimer()
1032                 io.Copy(dst, src)
1033         }
1034 }
1035
1036 func BenchmarkWriterCopyNoReadFrom(b *testing.B) {
1037         for i := 0; i < b.N; i++ {
1038                 b.StopTimer()
1039                 src := onlyReader{bytes.NewBuffer(make([]byte, 8192))}
1040                 dst := onlyWriter{NewWriter(new(bytes.Buffer))}
1041                 b.StartTimer()
1042                 io.Copy(dst, src)
1043         }
1044 }