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.
21 // Reads from a reader and rot13s the result.
22 type rot13Reader
struct {
26 func newRot13Reader(r io
.Reader
) *rot13Reader
{
27 r13
:= new(rot13Reader
)
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' {
38 } else if 'n' <= c
&& c
<= 'z' {
45 // Call ReadByte to accumulate the text of a file
46 func readBytes(buf
*Reader
) string {
50 c
, err
:= buf
.ReadByte()
57 } else if err
!= iotest
.ErrTimeout
{
58 panic("Data: " + err
.Error())
61 return string(b
[0:nb
])
64 func TestReaderSimple(t
*testing
.T
) {
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
)
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
)
77 type readMaker
struct {
79 fn
func(io
.Reader
) io
.Reader
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
},
90 // Call ReadString (which ends up calling everything else)
91 // to accumulate the text of a file.
92 func readLines(b
*Reader
) string {
95 s1
, err
:= b
.ReadString('\n')
99 if err
!= nil && err
!= iotest
.ErrTimeout
{
100 panic("GetLines: " + err
.Error())
107 // Call Read to accumulate the text of a file
108 func reads(buf
*Reader
, m
int) string {
112 n
, err
:= buf
.Read(b
[nb
: nb
+m
])
118 return string(b
[0:nb
])
121 type bufReader
struct {
123 fn
func(*Reader
) string
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
},
137 const minReadBufferSize
= 16
139 var bufsizes
= []int{
140 0, minReadBufferSize
, 23, 32, 46, 64, 93, 128, 1024, 4096,
143 func TestReader(t
*testing
.T
) {
147 for i
:= 0; i
< len(texts
)-1; i
++ {
148 texts
[i
] = str
+ "\n"
150 str
+= string(i%26
+ 'a')
152 texts
[len(texts
)-1] = all
154 for h
:= 0; h
< len(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
)
166 t
.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
167 readmaker
.name
, bufreader
.name
, bufsize
, text
, s
)
175 type zeroReader
struct{}
177 func (zeroReader
) Read(p
[]byte) (int, error
) {
181 func TestZeroReader(t
*testing
.T
) {
185 c
:= make(chan error
)
187 _
, err
:= r
.ReadByte()
194 t
.Error("error expected")
195 } else if err
!= io
.ErrNoProgress
{
196 t
.Error("unexpected error:", err
)
198 case <-time
.After(time
.Second
):
199 t
.Error("test timed out (endless loop in ReadByte?)")
203 // A StringReader delivers its data one string segment at a time via Read.
204 type StringReader
struct {
209 func (r
*StringReader
) Read(p
[]byte) (n
int, err error
) {
210 if r
.step
< len(r
.data
) {
220 func readRuneSegments(t
*testing
.T
, segments
[]string) {
222 want
:= strings
.Join(segments
, "")
223 r
:= NewReader(&StringReader
{data
: segments
})
225 r
, _
, err
:= r
.ReadRune()
235 t
.Errorf("segments=%v got=%s want=%s", segments
, got
, want
)
239 var segmentList
= [][]string{
243 {"\u65e5", "\u672c", "\u8a9e"},
244 {"\U000065e5", "\U0000672c", "\U00008a9e"},
245 {"\xe6", "\x97\xa5\xe6", "\x9c\xac\xe8\xaa\x9e"},
246 {"Hello", ", ", "World", "!"},
247 {"Hello", ", ", "", "World", "!"},
250 func TestReadRune(t
*testing
.T
) {
251 for _
, s
:= range segmentList
{
252 readRuneSegments(t
, s
)
256 func TestUnreadRune(t
*testing
.T
) {
257 segments
:= []string{"Hello, world:", "日本語"}
258 r
:= NewReader(&StringReader
{data
: segments
})
260 want
:= strings
.Join(segments
, "")
263 r1
, _
, err
:= r
.ReadRune()
266 t
.Error("unexpected error on ReadRune:", err
)
271 // Put it back and read it again.
272 if err
= r
.UnreadRune(); err
!= nil {
273 t
.Fatal("unexpected error on UnreadRune:", err
)
275 r2
, _
, err
:= r
.ReadRune()
277 t
.Fatal("unexpected error reading after unreading:", err
)
280 t
.Fatalf("incorrect rune after unread: got %c, want %c", r1
, r2
)
284 t
.Errorf("got %q, want %q", got
, want
)
288 func TestUnreadByte(t
*testing
.T
) {
289 segments
:= []string{"Hello, ", "world"}
290 r
:= NewReader(&StringReader
{data
: segments
})
292 want
:= strings
.Join(segments
, "")
295 b1
, err
:= r
.ReadByte()
298 t
.Error("unexpected error on ReadByte:", err
)
303 // Put it back and read it again.
304 if err
= r
.UnreadByte(); err
!= nil {
305 t
.Fatal("unexpected error on UnreadByte:", err
)
307 b2
, err
:= r
.ReadByte()
309 t
.Fatal("unexpected error reading after unreading:", err
)
312 t
.Fatalf("incorrect byte after unread: got %q, want %q", b1
, b2
)
316 t
.Errorf("got %q, want %q", got
, want
)
320 func TestUnreadByteMultiple(t
*testing
.T
) {
321 segments
:= []string{"Hello, ", "world"}
322 data
:= strings
.Join(segments
, "")
323 for n
:= 0; n
<= len(data
); n
++ {
324 r
:= NewReader(&StringReader
{data
: segments
})
326 for i
:= 0; i
< n
; i
++ {
327 b
, err
:= r
.ReadByte()
329 t
.Fatalf("n = %d: unexpected error on ReadByte: %v", n
, err
)
332 t
.Fatalf("n = %d: incorrect byte returned from ReadByte: got %q, want %q", n
, b
, data
[i
])
335 // Unread one byte if there is one.
337 if err
:= r
.UnreadByte(); err
!= nil {
338 t
.Errorf("n = %d: unexpected error on UnreadByte: %v", n
, err
)
341 // Test that we cannot unread any further.
342 if err
:= r
.UnreadByte(); err
== nil {
343 t
.Errorf("n = %d: expected error on UnreadByte", n
)
348 func TestUnreadByteOthers(t
*testing
.T
) {
349 // A list of readers to use in conjunction with UnreadByte.
350 var readers
= []func(*Reader
, byte) ([]byte, error
){
353 func(r
*Reader
, delim
byte) ([]byte, error
) {
354 data
, err
:= r
.ReadString(delim
)
355 return []byte(data
), err
357 // ReadLine doesn't fit the data/pattern easily
358 // so we leave it out. It should be covered via
359 // the ReadSlice test since ReadLine simply calls
360 // ReadSlice, and it's that function that handles
364 // Try all readers with UnreadByte.
365 for rno
, read
:= range readers
{
366 // Some input data that is longer than the minimum reader buffer size.
369 for i
:= 0; i
< n
; i
++ {
370 buf
.WriteString("abcdefg")
373 r
:= NewReaderSize(&buf
, minReadBufferSize
)
374 readTo
:= func(delim
byte, want
string) {
375 data
, err
:= read(r
, delim
)
377 t
.Fatalf("#%d: unexpected error reading to %c: %v", rno
, delim
, err
)
379 if got
:= string(data
); got
!= want
{
380 t
.Fatalf("#%d: got %q, want %q", rno
, got
, want
)
384 // Read the data with occasional UnreadByte calls.
385 for i
:= 0; i
< n
; i
++ {
387 for j
:= 0; j
< 3; j
++ {
388 if err
:= r
.UnreadByte(); err
!= nil {
389 t
.Fatalf("#%d: unexpected error on UnreadByte: %v", rno
, err
)
396 // All data should have been read.
397 _
, err
:= r
.ReadByte()
399 t
.Errorf("#%d: got error %v; want EOF", rno
, err
)
404 // Test that UnreadRune fails if the preceding operation was not a ReadRune.
405 func TestUnreadRuneError(t
*testing
.T
) {
406 buf
:= make([]byte, 3) // All runes in this test are 3 bytes long
407 r
:= NewReader(&StringReader
{data
: []string{"日本語日本語日本語"}})
408 if r
.UnreadRune() == nil {
409 t
.Error("expected error on UnreadRune from fresh buffer")
411 _
, _
, err
:= r
.ReadRune()
413 t
.Error("unexpected error on ReadRune (1):", err
)
415 if err
= r
.UnreadRune(); err
!= nil {
416 t
.Error("unexpected error on UnreadRune (1):", err
)
418 if r
.UnreadRune() == nil {
419 t
.Error("expected error after UnreadRune (1)")
421 // Test error after Read.
422 _
, _
, err
= r
.ReadRune() // reset state
424 t
.Error("unexpected error on ReadRune (2):", err
)
428 t
.Error("unexpected error on Read (2):", err
)
430 if r
.UnreadRune() == nil {
431 t
.Error("expected error after Read (2)")
433 // Test error after ReadByte.
434 _
, _
, err
= r
.ReadRune() // reset state
436 t
.Error("unexpected error on ReadRune (2):", err
)
439 _
, err
= r
.ReadByte()
441 t
.Error("unexpected error on ReadByte (2):", err
)
444 if r
.UnreadRune() == nil {
445 t
.Error("expected error after ReadByte")
447 // Test error after UnreadByte.
448 _
, _
, err
= r
.ReadRune() // reset state
450 t
.Error("unexpected error on ReadRune (3):", err
)
452 _
, err
= r
.ReadByte()
454 t
.Error("unexpected error on ReadByte (3):", err
)
458 t
.Error("unexpected error on UnreadByte (3):", err
)
460 if r
.UnreadRune() == nil {
461 t
.Error("expected error after UnreadByte (3)")
463 // Test error after ReadSlice.
464 _
, _
, err
= r
.ReadRune() // reset state
466 t
.Error("unexpected error on ReadRune (4):", err
)
468 _
, err
= r
.ReadSlice(0)
470 t
.Error("unexpected error on ReadSlice (4):", err
)
472 if r
.UnreadRune() == nil {
473 t
.Error("expected error after ReadSlice (4)")
477 func TestUnreadRuneAtEOF(t
*testing
.T
) {
478 // UnreadRune/ReadRune should error at EOF (was a bug; used to panic)
479 r
:= NewReader(strings
.NewReader("x"))
483 _
, _
, err
:= r
.ReadRune()
485 t
.Error("expected error at EOF")
486 } else if err
!= io
.EOF
{
487 t
.Error("expected EOF; got", err
)
491 func TestReadWriteRune(t
*testing
.T
) {
493 byteBuf
:= new(bytes
.Buffer
)
494 w
:= NewWriter(byteBuf
)
495 // Write the runes out using WriteRune
496 buf
:= make([]byte, utf8
.UTFMax
)
497 for r
:= rune(0); r
< NRune
; r
++ {
498 size
:= utf8
.EncodeRune(buf
, r
)
499 nbytes
, err
:= w
.WriteRune(r
)
501 t
.Fatalf("WriteRune(0x%x) error: %s", r
, err
)
504 t
.Fatalf("WriteRune(0x%x) expected %d, got %d", r
, size
, nbytes
)
509 r
:= NewReader(byteBuf
)
510 // Read them back with ReadRune
511 for r1
:= rune(0); r1
< NRune
; r1
++ {
512 size
:= utf8
.EncodeRune(buf
, r1
)
513 nr
, nbytes
, err
:= r
.ReadRune()
514 if nr
!= r1 || nbytes
!= size || err
!= nil {
515 t
.Fatalf("ReadRune(0x%x) got 0x%x,%d not 0x%x,%d (err=%s)", r1
, nr
, nbytes
, r1
, size
, err
)
520 func TestWriter(t
*testing
.T
) {
523 for i
:= 0; i
< len(data
); i
++ {
524 data
[i
] = byte(' ' + i
%('~'-' '))
526 w
:= new(bytes
.Buffer
)
527 for i
:= 0; i
< len(bufsizes
); i
++ {
528 for j
:= 0; j
< len(bufsizes
); j
++ {
529 nwrite
:= bufsizes
[i
]
532 // Write nwrite bytes using buffer size bs.
533 // Check that the right amount makes it out
534 // and that the data is correct.
537 buf
:= NewWriterSize(w
, bs
)
538 context
:= fmt
.Sprintf("nwrite=%d bufsize=%d", nwrite
, bs
)
539 n
, e1
:= buf
.Write(data
[0:nwrite
])
540 if e1
!= nil || n
!= nwrite
{
541 t
.Errorf("%s: buf.Write %d = %d, %v", context
, nwrite
, n
, e1
)
544 if e
:= buf
.Flush(); e
!= nil {
545 t
.Errorf("%s: buf.Flush = %v", context
, e
)
549 if len(written
) != nwrite
{
550 t
.Errorf("%s: %d bytes written", context
, len(written
))
552 for l
:= 0; l
< len(written
); l
++ {
553 if written
[i
] != data
[i
] {
554 t
.Errorf("wrong bytes written")
555 t
.Errorf("want=%q", data
[0:len(written
)])
556 t
.Errorf("have=%q", written
)
563 // Check that write errors are returned properly.
565 type errorWriterTest
struct {
571 func (w errorWriterTest
) Write(p
[]byte) (int, error
) {
572 return len(p
) * w
.n
/ w
.m
, w
.err
575 var errorWriterTests
= []errorWriterTest
{
576 {0, 1, nil, io
.ErrShortWrite
},
577 {1, 2, nil, io
.ErrShortWrite
},
579 {0, 1, io
.ErrClosedPipe
, io
.ErrClosedPipe
},
580 {1, 2, io
.ErrClosedPipe
, io
.ErrClosedPipe
},
581 {1, 1, io
.ErrClosedPipe
, io
.ErrClosedPipe
},
584 func TestWriteErrors(t
*testing
.T
) {
585 for _
, w
:= range errorWriterTests
{
587 _
, e
:= buf
.Write([]byte("hello world"))
589 t
.Errorf("Write hello to %v: %v", w
, e
)
592 // Two flushes, to verify the error is sticky.
593 for i
:= 0; i
< 2; i
++ {
596 t
.Errorf("Flush %d/2 %v: got %v, wanted %v", i
+1, w
, e
, w
.expect
)
602 func TestNewReaderSizeIdempotent(t
*testing
.T
) {
604 b
:= NewReaderSize(strings
.NewReader("hello world"), BufSize
)
605 // Does it recognize itself?
606 b1
:= NewReaderSize(b
, BufSize
)
608 t
.Error("NewReaderSize did not detect underlying Reader")
610 // Does it wrap if existing buffer is too small?
611 b2
:= NewReaderSize(b
, 2*BufSize
)
613 t
.Error("NewReaderSize did not enlarge buffer")
617 func TestNewWriterSizeIdempotent(t
*testing
.T
) {
619 b
:= NewWriterSize(new(bytes
.Buffer
), BufSize
)
620 // Does it recognize itself?
621 b1
:= NewWriterSize(b
, BufSize
)
623 t
.Error("NewWriterSize did not detect underlying Writer")
625 // Does it wrap if existing buffer is too small?
626 b2
:= NewWriterSize(b
, 2*BufSize
)
628 t
.Error("NewWriterSize did not enlarge buffer")
632 func TestWriteString(t
*testing
.T
) {
634 buf
:= new(bytes
.Buffer
)
635 b
:= NewWriterSize(buf
, BufSize
)
636 b
.WriteString("0") // easy
637 b
.WriteString("123456") // still easy
638 b
.WriteString("7890") // easy after flush
639 b
.WriteString("abcdefghijklmnopqrstuvwxy") // hard
641 if err
:= b
.Flush(); err
!= nil {
642 t
.Error("WriteString", err
)
644 s
:= "01234567890abcdefghijklmnopqrstuvwxyz"
645 if string(buf
.Bytes()) != s
{
646 t
.Errorf("WriteString wants %q gets %q", s
, string(buf
.Bytes()))
650 func TestBufferFull(t
*testing
.T
) {
651 const longString
= "And now, hello, world! It is the time for all good men to come to the aid of their party"
652 buf
:= NewReaderSize(strings
.NewReader(longString
), minReadBufferSize
)
653 line
, err
:= buf
.ReadSlice('!')
654 if string(line
) != "And now, hello, " || err
!= ErrBufferFull
{
655 t
.Errorf("first ReadSlice(,) = %q, %v", line
, err
)
657 line
, err
= buf
.ReadSlice('!')
658 if string(line
) != "world!" || err
!= nil {
659 t
.Errorf("second ReadSlice(,) = %q, %v", line
, err
)
663 func TestPeek(t
*testing
.T
) {
664 p
:= make([]byte, 10)
665 // string is 16 (minReadBufferSize) long.
666 buf
:= NewReaderSize(strings
.NewReader("abcdefghijklmnop"), minReadBufferSize
)
667 if s
, err
:= buf
.Peek(1); string(s
) != "a" || err
!= nil {
668 t
.Fatalf("want %q got %q, err=%v", "a", string(s
), err
)
670 if s
, err
:= buf
.Peek(4); string(s
) != "abcd" || err
!= nil {
671 t
.Fatalf("want %q got %q, err=%v", "abcd", string(s
), err
)
673 if _
, err
:= buf
.Peek(-1); err
!= ErrNegativeCount
{
674 t
.Fatalf("want ErrNegativeCount got %v", err
)
676 if s
, err
:= buf
.Peek(32); string(s
) != "abcdefghijklmnop" || err
!= ErrBufferFull
{
677 t
.Fatalf("want %q, ErrBufFull got %q, err=%v", "abcdefghijklmnop", string(s
), err
)
679 if _
, err
:= buf
.Read(p
[0:3]); string(p
[0:3]) != "abc" || err
!= nil {
680 t
.Fatalf("want %q got %q, err=%v", "abc", string(p
[0:3]), err
)
682 if s
, err
:= buf
.Peek(1); string(s
) != "d" || err
!= nil {
683 t
.Fatalf("want %q got %q, err=%v", "d", string(s
), err
)
685 if s
, err
:= buf
.Peek(2); string(s
) != "de" || err
!= nil {
686 t
.Fatalf("want %q got %q, err=%v", "de", string(s
), err
)
688 if _
, err
:= buf
.Read(p
[0:3]); string(p
[0:3]) != "def" || err
!= nil {
689 t
.Fatalf("want %q got %q, err=%v", "def", string(p
[0:3]), err
)
691 if s
, err
:= buf
.Peek(4); string(s
) != "ghij" || err
!= nil {
692 t
.Fatalf("want %q got %q, err=%v", "ghij", string(s
), err
)
694 if _
, err
:= buf
.Read(p
[0:]); string(p
[0:]) != "ghijklmnop" || err
!= nil {
695 t
.Fatalf("want %q got %q, err=%v", "ghijklmnop", string(p
[0:minReadBufferSize
]), err
)
697 if s
, err
:= buf
.Peek(0); string(s
) != "" || err
!= nil {
698 t
.Fatalf("want %q got %q, err=%v", "", string(s
), err
)
700 if _
, err
:= buf
.Peek(1); err
!= io
.EOF
{
701 t
.Fatalf("want EOF got %v", err
)
704 // Test for issue 3022, not exposing a reader's error on a successful Peek.
705 buf
= NewReaderSize(dataAndEOFReader("abcd"), 32)
706 if s
, err
:= buf
.Peek(2); string(s
) != "ab" || err
!= nil {
707 t
.Errorf(`Peek(2) on "abcd", EOF = %q, %v; want "ab", nil`, string(s
), err
)
709 if s
, err
:= buf
.Peek(4); string(s
) != "abcd" || err
!= nil {
710 t
.Errorf(`Peek(4) on "abcd", EOF = %q, %v; want "abcd", nil`, string(s
), err
)
712 if n
, err
:= buf
.Read(p
[0:5]); string(p
[0:n
]) != "abcd" || err
!= nil {
713 t
.Fatalf("Read after peek = %q, %v; want abcd, EOF", p
[0:n
], err
)
715 if n
, err
:= buf
.Read(p
[0:1]); string(p
[0:n
]) != "" || err
!= io
.EOF
{
716 t
.Fatalf(`second Read after peek = %q, %v; want "", EOF`, p
[0:n
], err
)
720 type dataAndEOFReader
string
722 func (r dataAndEOFReader
) Read(p
[]byte) (int, error
) {
723 return copy(p
, r
), io
.EOF
726 func TestPeekThenUnreadRune(t
*testing
.T
) {
727 // This sequence used to cause a crash.
728 r
:= NewReader(strings
.NewReader("x"))
732 r
.ReadRune() // Used to panic here
735 var testOutput
= []byte("0123456789abcdefghijklmnopqrstuvwxy")
736 var testInput
= []byte("012\n345\n678\n9ab\ncde\nfgh\nijk\nlmn\nopq\nrst\nuvw\nxy")
737 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")
739 // TestReader wraps a []byte and returns reads of a specific length.
740 type testReader
struct {
745 func (t
*testReader
) Read(buf
[]byte) (n
int, err error
) {
755 if len(t
.data
) == 0 {
761 func testReadLine(t
*testing
.T
, input
[]byte) {
762 //for stride := 1; stride < len(input); stride++ {
763 for stride
:= 1; stride
< 2; stride
++ {
765 reader
:= testReader
{input
, stride
}
766 l
:= NewReaderSize(&reader
, len(input
)+1)
768 line
, isPrefix
, err
:= l
.ReadLine()
769 if len(line
) > 0 && err
!= nil {
770 t
.Errorf("ReadLine returned both data and error: %s", err
)
773 t
.Errorf("ReadLine returned prefix")
777 t
.Fatalf("Got unknown error: %s", err
)
781 if want
:= testOutput
[done
: done
+len(line
)]; !bytes
.Equal(want
, line
) {
782 t
.Errorf("Bad line at stride %d: want: %x got: %x", stride
, want
, line
)
786 if done
!= len(testOutput
) {
787 t
.Errorf("ReadLine didn't return everything: got: %d, want: %d (stride: %d)", done
, len(testOutput
), stride
)
792 func TestReadLine(t
*testing
.T
) {
793 testReadLine(t
, testInput
)
794 testReadLine(t
, testInputrn
)
797 func TestLineTooLong(t
*testing
.T
) {
798 data
:= make([]byte, 0)
799 for i
:= 0; i
< minReadBufferSize
*5/2; i
++ {
800 data
= append(data
, '0'+byte(i%10
))
802 buf
:= bytes
.NewReader(data
)
803 l
:= NewReaderSize(buf
, minReadBufferSize
)
804 line
, isPrefix
, err
:= l
.ReadLine()
805 if !isPrefix ||
!bytes
.Equal(line
, data
[:minReadBufferSize
]) || err
!= nil {
806 t
.Errorf("bad result for first line: got %q want %q %v", line
, data
[:minReadBufferSize
], err
)
808 data
= data
[len(line
):]
809 line
, isPrefix
, err
= l
.ReadLine()
810 if !isPrefix ||
!bytes
.Equal(line
, data
[:minReadBufferSize
]) || err
!= nil {
811 t
.Errorf("bad result for second line: got %q want %q %v", line
, data
[:minReadBufferSize
], err
)
813 data
= data
[len(line
):]
814 line
, isPrefix
, err
= l
.ReadLine()
815 if isPrefix ||
!bytes
.Equal(line
, data
[:minReadBufferSize
/2]) || err
!= nil {
816 t
.Errorf("bad result for third line: got %q want %q %v", line
, data
[:minReadBufferSize
/2], err
)
818 line
, isPrefix
, err
= l
.ReadLine()
819 if isPrefix || err
== nil {
820 t
.Errorf("expected no more lines: %x %s", line
, err
)
824 func TestReadAfterLines(t
*testing
.T
) {
825 line1
:= "this is line1"
826 restData
:= "this is line2\nthis is line 3\n"
827 inbuf
:= bytes
.NewReader([]byte(line1
+ "\n" + restData
))
828 outbuf
:= new(bytes
.Buffer
)
829 maxLineLength
:= len(line1
) + len(restData
)/2
830 l
:= NewReaderSize(inbuf
, maxLineLength
)
831 line
, isPrefix
, err
:= l
.ReadLine()
832 if isPrefix || err
!= nil ||
string(line
) != line1
{
833 t
.Errorf("bad result for first line: isPrefix=%v err=%v line=%q", isPrefix
, err
, string(line
))
835 n
, err
:= io
.Copy(outbuf
, l
)
836 if int(n
) != len(restData
) || err
!= nil {
837 t
.Errorf("bad result for Read: n=%d err=%v", n
, err
)
839 if outbuf
.String() != restData
{
840 t
.Errorf("bad result for Read: got %q; expected %q", outbuf
.String(), restData
)
844 func TestReadEmptyBuffer(t
*testing
.T
) {
845 l
:= NewReaderSize(new(bytes
.Buffer
), minReadBufferSize
)
846 line
, isPrefix
, err
:= l
.ReadLine()
848 t
.Errorf("expected EOF from ReadLine, got '%s' %t %s", line
, isPrefix
, err
)
852 func TestLinesAfterRead(t
*testing
.T
) {
853 l
:= NewReaderSize(bytes
.NewReader([]byte("foo")), minReadBufferSize
)
854 _
, err
:= ioutil
.ReadAll(l
)
860 line
, isPrefix
, err
:= l
.ReadLine()
862 t
.Errorf("expected EOF from ReadLine, got '%s' %t %s", line
, isPrefix
, err
)
866 func TestReadLineNonNilLineOrError(t
*testing
.T
) {
867 r
:= NewReader(strings
.NewReader("line 1\n"))
868 for i
:= 0; i
< 2; i
++ {
869 l
, _
, err
:= r
.ReadLine()
870 if l
!= nil && err
!= nil {
871 t
.Fatalf("on line %d/2; ReadLine=%#v, %v; want non-nil line or Error, but not both",
877 type readLineResult
struct {
883 var readLineNewlinesTests
= []struct {
885 expect
[]readLineResult
887 {"012345678901234\r\n012345678901234\r\n", []readLineResult
{
888 {[]byte("012345678901234"), true, nil},
890 {[]byte("012345678901234"), true, nil},
892 {nil, false, io
.EOF
},
894 {"0123456789012345\r012345678901234\r", []readLineResult
{
895 {[]byte("0123456789012345"), true, nil},
896 {[]byte("\r012345678901234"), true, nil},
897 {[]byte("\r"), false, nil},
898 {nil, false, io
.EOF
},
902 func TestReadLineNewlines(t
*testing
.T
) {
903 for _
, e
:= range readLineNewlinesTests
{
904 testReadLineNewlines(t
, e
.input
, e
.expect
)
908 func testReadLineNewlines(t
*testing
.T
, input
string, expect
[]readLineResult
) {
909 b
:= NewReaderSize(strings
.NewReader(input
), minReadBufferSize
)
910 for i
, e
:= range expect
{
911 line
, isPrefix
, err
:= b
.ReadLine()
912 if !bytes
.Equal(line
, e
.line
) {
913 t
.Errorf("%q call %d, line == %q, want %q", input
, i
, line
, e
.line
)
916 if isPrefix
!= e
.isPrefix
{
917 t
.Errorf("%q call %d, isPrefix == %v, want %v", input
, i
, isPrefix
, e
.isPrefix
)
921 t
.Errorf("%q call %d, err == %v, want %v", input
, i
, err
, e
.err
)
927 func createTestInput(n
int) []byte {
928 input
:= make([]byte, n
)
929 for i
:= range input
{
930 // 101 and 251 are arbitrary prime numbers.
931 // The idea is to create an input sequence
932 // which doesn't repeat too frequently.
933 input
[i
] = byte(i
% 251)
935 input
[i
] ^= byte(i
/ 101)
941 func TestReaderWriteTo(t
*testing
.T
) {
942 input
:= createTestInput(8192)
943 r
:= NewReader(onlyReader
{bytes
.NewReader(input
)})
944 w
:= new(bytes
.Buffer
)
945 if n
, err
:= r
.WriteTo(w
); err
!= nil || n
!= int64(len(input
)) {
946 t
.Fatalf("r.WriteTo(w) = %d, %v, want %d, nil", n
, err
, len(input
))
949 for i
, val
:= range w
.Bytes() {
951 t
.Errorf("after write: out[%d] = %#x, want %#x", i
, val
, input
[i
])
956 type errorWriterToTest
struct {
962 func (r errorWriterToTest
) Read(p
[]byte) (int, error
) {
963 return len(p
) * r
.rn
, r
.rerr
966 func (w errorWriterToTest
) Write(p
[]byte) (int, error
) {
967 return len(p
) * w
.wn
, w
.werr
970 var errorWriterToTests
= []errorWriterToTest
{
971 {1, 0, nil, io
.ErrClosedPipe
, io
.ErrClosedPipe
},
972 {0, 1, io
.ErrClosedPipe
, nil, io
.ErrClosedPipe
},
973 {0, 0, io
.ErrUnexpectedEOF
, io
.ErrClosedPipe
, io
.ErrClosedPipe
},
974 {0, 1, io
.EOF
, nil, nil},
977 func TestReaderWriteToErrors(t
*testing
.T
) {
978 for i
, rw
:= range errorWriterToTests
{
980 if _
, err
:= r
.WriteTo(rw
); err
!= rw
.expected
{
981 t
.Errorf("r.WriteTo(errorWriterToTests[%d]) = _, %v, want _,%v", i
, err
, rw
.expected
)
986 func TestWriterReadFrom(t
*testing
.T
) {
987 ws
:= []func(io
.Writer
) io
.Writer
{
988 func(w io
.Writer
) io
.Writer
{ return onlyWriter
{w
} },
989 func(w io
.Writer
) io
.Writer
{ return w
},
992 rs
:= []func(io
.Reader
) io
.Reader
{
993 iotest
.DataErrReader
,
994 func(r io
.Reader
) io
.Reader
{ return r
},
997 for ri
, rfunc
:= range rs
{
998 for wi
, wfunc
:= range ws
{
999 input
:= createTestInput(8192)
1000 b
:= new(bytes
.Buffer
)
1001 w
:= NewWriter(wfunc(b
))
1002 r
:= rfunc(bytes
.NewReader(input
))
1003 if n
, err
:= w
.ReadFrom(r
); err
!= nil || n
!= int64(len(input
)) {
1004 t
.Errorf("ws[%d],rs[%d]: w.ReadFrom(r) = %d, %v, want %d, nil", wi
, ri
, n
, err
, len(input
))
1007 if err
:= w
.Flush(); err
!= nil {
1008 t
.Errorf("Flush returned %v", err
)
1011 if got
, want
:= b
.String(), string(input
); got
!= want
{
1012 t
.Errorf("ws[%d], rs[%d]:\ngot %q\nwant %q\n", wi
, ri
, got
, want
)
1018 type errorReaderFromTest
struct {
1024 func (r errorReaderFromTest
) Read(p
[]byte) (int, error
) {
1025 return len(p
) * r
.rn
, r
.rerr
1028 func (w errorReaderFromTest
) Write(p
[]byte) (int, error
) {
1029 return len(p
) * w
.wn
, w
.werr
1032 var errorReaderFromTests
= []errorReaderFromTest
{
1033 {0, 1, io
.EOF
, nil, nil},
1034 {1, 1, io
.EOF
, nil, nil},
1035 {0, 1, io
.ErrClosedPipe
, nil, io
.ErrClosedPipe
},
1036 {0, 0, io
.ErrClosedPipe
, io
.ErrShortWrite
, io
.ErrClosedPipe
},
1037 {1, 0, nil, io
.ErrShortWrite
, io
.ErrShortWrite
},
1040 func TestWriterReadFromErrors(t
*testing
.T
) {
1041 for i
, rw
:= range errorReaderFromTests
{
1043 if _
, err
:= w
.ReadFrom(rw
); err
!= rw
.expected
{
1044 t
.Errorf("w.ReadFrom(errorReaderFromTests[%d]) = _, %v, want _,%v", i
, err
, rw
.expected
)
1049 // TestWriterReadFromCounts tests that using io.Copy to copy into a
1050 // bufio.Writer does not prematurely flush the buffer. For example, when
1051 // buffering writes to a network socket, excessive network writes should be
1053 func TestWriterReadFromCounts(t
*testing
.T
) {
1054 var w0 writeCountingDiscard
1055 b0
:= NewWriterSize(&w0
, 1234)
1056 b0
.WriteString(strings
.Repeat("x", 1000))
1058 t
.Fatalf("write 1000 'x's: got %d writes, want 0", w0
)
1060 b0
.WriteString(strings
.Repeat("x", 200))
1062 t
.Fatalf("write 1200 'x's: got %d writes, want 0", w0
)
1064 io
.Copy(b0
, onlyReader
{strings
.NewReader(strings
.Repeat("x", 30))})
1066 t
.Fatalf("write 1230 'x's: got %d writes, want 0", w0
)
1068 io
.Copy(b0
, onlyReader
{strings
.NewReader(strings
.Repeat("x", 9))})
1070 t
.Fatalf("write 1239 'x's: got %d writes, want 1", w0
)
1073 var w1 writeCountingDiscard
1074 b1
:= NewWriterSize(&w1
, 1234)
1075 b1
.WriteString(strings
.Repeat("x", 1200))
1078 t
.Fatalf("flush 1200 'x's: got %d writes, want 1", w1
)
1080 b1
.WriteString(strings
.Repeat("x", 89))
1082 t
.Fatalf("write 1200 + 89 'x's: got %d writes, want 1", w1
)
1084 io
.Copy(b1
, onlyReader
{strings
.NewReader(strings
.Repeat("x", 700))})
1086 t
.Fatalf("write 1200 + 789 'x's: got %d writes, want 1", w1
)
1088 io
.Copy(b1
, onlyReader
{strings
.NewReader(strings
.Repeat("x", 600))})
1090 t
.Fatalf("write 1200 + 1389 'x's: got %d writes, want 2", w1
)
1094 t
.Fatalf("flush 1200 + 1389 'x's: got %d writes, want 3", w1
)
1098 // A writeCountingDiscard is like ioutil.Discard and counts the number of times
1099 // Write is called on it.
1100 type writeCountingDiscard
int
1102 func (w
*writeCountingDiscard
) Write(p
[]byte) (int, error
) {
1107 type negativeReader
int
1109 func (r
*negativeReader
) Read([]byte) (int, error
) { return -1, nil }
1111 func TestNegativeRead(t
*testing
.T
) {
1112 // should panic with a description pointing at the reader, not at itself.
1113 // (should NOT panic with slice index error, for example.)
1114 b
:= NewReader(new(negativeReader
))
1116 switch err
:= recover().(type) {
1118 t
.Fatal("read did not panic")
1120 if !strings
.Contains(err
.Error(), "reader returned negative count from Read") {
1121 t
.Fatalf("wrong panic: %v", err
)
1124 t
.Fatalf("unexpected panic value: %T(%v)", err
, err
)
1127 b
.Read(make([]byte, 100))
1130 var errFake
= errors
.New("fake error")
1132 type errorThenGoodReader
struct {
1137 func (r
*errorThenGoodReader
) Read(p
[]byte) (int, error
) {
1146 func TestReaderClearError(t
*testing
.T
) {
1147 r
:= &errorThenGoodReader
{}
1149 buf
:= make([]byte, 1)
1150 if _
, err
:= b
.Read(nil); err
!= nil {
1151 t
.Fatalf("1st nil Read = %v; want nil", err
)
1153 if _
, err
:= b
.Read(buf
); err
!= errFake
{
1154 t
.Fatalf("1st Read = %v; want errFake", err
)
1156 if _
, err
:= b
.Read(nil); err
!= nil {
1157 t
.Fatalf("2nd nil Read = %v; want nil", err
)
1159 if _
, err
:= b
.Read(buf
); err
!= nil {
1160 t
.Fatalf("3rd Read with buffer = %v; want nil", err
)
1163 t
.Errorf("num reads = %d; want 2", r
.nread
)
1167 // Test for golang.org/issue/5947
1168 func TestWriterReadFromWhileFull(t
*testing
.T
) {
1169 buf
:= new(bytes
.Buffer
)
1170 w
:= NewWriterSize(buf
, 10)
1172 // Fill buffer exactly.
1173 n
, err
:= w
.Write([]byte("0123456789"))
1174 if n
!= 10 || err
!= nil {
1175 t
.Fatalf("Write returned (%v, %v), want (10, nil)", n
, err
)
1178 // Use ReadFrom to read in some data.
1179 n2
, err
:= w
.ReadFrom(strings
.NewReader("abcdef"))
1180 if n2
!= 6 || err
!= nil {
1181 t
.Fatalf("ReadFrom returned (%v, %v), want (6, nil)", n2
, err
)
1185 type emptyThenNonEmptyReader
struct {
1190 func (r
*emptyThenNonEmptyReader
) Read(p
[]byte) (int, error
) {
1198 // Test for golang.org/issue/7611
1199 func TestWriterReadFromUntilEOF(t
*testing
.T
) {
1200 buf
:= new(bytes
.Buffer
)
1201 w
:= NewWriterSize(buf
, 5)
1203 // Partially fill buffer
1204 n
, err
:= w
.Write([]byte("0123"))
1205 if n
!= 4 || err
!= nil {
1206 t
.Fatalf("Write returned (%v, %v), want (4, nil)", n
, err
)
1209 // Use ReadFrom to read in some data.
1210 r
:= &emptyThenNonEmptyReader
{r
: strings
.NewReader("abcd"), n
: 3}
1211 n2
, err
:= w
.ReadFrom(r
)
1212 if n2
!= 4 || err
!= nil {
1213 t
.Fatalf("ReadFrom returned (%v, %v), want (4, nil)", n2
, err
)
1216 if got
, want
:= string(buf
.Bytes()), "0123abcd"; got
!= want
{
1217 t
.Fatalf("buf.Bytes() returned %q, want %q", got
, want
)
1221 func TestWriterReadFromErrNoProgress(t
*testing
.T
) {
1222 buf
:= new(bytes
.Buffer
)
1223 w
:= NewWriterSize(buf
, 5)
1225 // Partially fill buffer
1226 n
, err
:= w
.Write([]byte("0123"))
1227 if n
!= 4 || err
!= nil {
1228 t
.Fatalf("Write returned (%v, %v), want (4, nil)", n
, err
)
1231 // Use ReadFrom to read in some data.
1232 r
:= &emptyThenNonEmptyReader
{r
: strings
.NewReader("abcd"), n
: 100}
1233 n2
, err
:= w
.ReadFrom(r
)
1234 if n2
!= 0 || err
!= io
.ErrNoProgress
{
1235 t
.Fatalf("buf.Bytes() returned (%v, %v), want (0, io.ErrNoProgress)", n2
, err
)
1239 func TestReadZero(t
*testing
.T
) {
1240 for _
, size
:= range []int{100, 2} {
1241 t
.Run(fmt
.Sprintf("bufsize=%d", size
), func(t
*testing
.T
) {
1242 r
:= io
.MultiReader(strings
.NewReader("abc"), &emptyThenNonEmptyReader
{r
: strings
.NewReader("def"), n
: 1})
1243 br
:= NewReaderSize(r
, size
)
1244 want
:= func(s
string, wantErr error
) {
1245 p
:= make([]byte, 50)
1246 n
, err
:= br
.Read(p
)
1247 if err
!= wantErr || n
!= len(s
) ||
string(p
[:n
]) != s
{
1248 t
.Fatalf("read(%d) = %q, %v, want %q, %v", len(p
), string(p
[:n
]), err
, s
, wantErr
)
1250 t
.Logf("read(%d) = %q, %v", len(p
), string(p
[:n
]), err
)
1260 func TestReaderReset(t
*testing
.T
) {
1261 r
:= NewReader(strings
.NewReader("foo foo"))
1262 buf
:= make([]byte, 3)
1264 if string(buf
) != "foo" {
1265 t
.Errorf("buf = %q; want foo", buf
)
1267 r
.Reset(strings
.NewReader("bar bar"))
1268 all
, err
:= ioutil
.ReadAll(r
)
1272 if string(all
) != "bar bar" {
1273 t
.Errorf("ReadAll = %q; want bar bar", all
)
1277 func TestWriterReset(t
*testing
.T
) {
1278 var buf1
, buf2 bytes
.Buffer
1279 w
:= NewWriter(&buf1
)
1280 w
.WriteString("foo")
1281 w
.Reset(&buf2
) // and not flushed
1282 w
.WriteString("bar")
1284 if buf1
.String() != "" {
1285 t
.Errorf("buf1 = %q; want empty", buf1
.String())
1287 if buf2
.String() != "bar" {
1288 t
.Errorf("buf2 = %q; want bar", buf2
.String())
1292 func TestReaderDiscard(t
*testing
.T
) {
1296 bufSize
int // 0 means 16
1299 n
int // input to Discard
1301 want
int // from Discard
1302 wantErr error
// from Discard
1307 name
: "normal case",
1308 r
: strings
.NewReader("abcdefghijklmnopqrstuvwxyz"),
1315 name
: "discard causing read",
1316 r
: strings
.NewReader("abcdefghijklmnopqrstuvwxyz"),
1322 name
: "discard all without peek",
1323 r
: strings
.NewReader("abcdefghijklmnopqrstuvwxyz"),
1329 name
: "discard more than end",
1330 r
: strings
.NewReader("abcdefghijklmnopqrstuvwxyz"),
1336 // Any error from filling shouldn't show up until we
1337 // get past the valid bytes. Here we return we return 5 valid bytes at the same time
1338 // as an error, but test that we don't see the error from Discard.
1340 name
: "fill error, discard less",
1341 r
: newScriptedReader(func(p
[]byte) (n
int, err error
) {
1343 panic("unexpected small read")
1345 return 5, errors
.New("5-then-error")
1353 name
: "fill error, discard equal",
1354 r
: newScriptedReader(func(p
[]byte) (n
int, err error
) {
1356 panic("unexpected small read")
1358 return 5, errors
.New("5-then-error")
1366 name
: "fill error, discard more",
1367 r
: newScriptedReader(func(p
[]byte) (n
int, err error
) {
1369 panic("unexpected small read")
1371 return 5, errors
.New("5-then-error")
1375 wantErr
: errors
.New("5-then-error"),
1378 // Discard of 0 shouldn't cause a read:
1380 name
: "discard zero",
1381 r
: newScriptedReader(), // will panic on Read
1388 name
: "discard negative",
1389 r
: newScriptedReader(), // will panic on Read
1392 wantErr
: ErrNegativeCount
,
1396 for _
, tt
:= range tests
{
1397 br
:= NewReaderSize(tt
.r
, tt
.bufSize
)
1398 if tt
.peekSize
> 0 {
1399 peekBuf
, err
:= br
.Peek(tt
.peekSize
)
1401 t
.Errorf("%s: Peek(%d): %v", tt
.name
, tt
.peekSize
, err
)
1404 if len(peekBuf
) != tt
.peekSize
{
1405 t
.Errorf("%s: len(Peek(%d)) = %v; want %v", tt
.name
, tt
.peekSize
, len(peekBuf
), tt
.peekSize
)
1409 discarded
, err
:= br
.Discard(tt
.n
)
1410 if ge
, we
:= fmt
.Sprint(err
), fmt
.Sprint(tt
.wantErr
); discarded
!= tt
.want || ge
!= we
{
1411 t
.Errorf("%s: Discard(%d) = (%v, %v); want (%v, %v)", tt
.name
, tt
.n
, discarded
, ge
, tt
.want
, we
)
1414 if bn
:= br
.Buffered(); bn
!= tt
.wantBuffered
{
1415 t
.Errorf("%s: after Discard, Buffered = %d; want %d", tt
.name
, bn
, tt
.wantBuffered
)
1421 // An onlyReader only implements io.Reader, no matter what other methods the underlying implementation may have.
1422 type onlyReader
struct {
1426 // An onlyWriter only implements io.Writer, no matter what other methods the underlying implementation may have.
1427 type onlyWriter
struct {
1431 // A scriptedReader is an io.Reader that executes its steps sequentially.
1432 type scriptedReader
[]func(p
[]byte) (n
int, err error
)
1434 func (sr
*scriptedReader
) Read(p
[]byte) (n
int, err error
) {
1436 panic("too many Read calls on scripted Reader. No steps remain.")
1443 func newScriptedReader(steps
...func(p
[]byte) (n
int, err error
)) io
.Reader
{
1444 sr
:= scriptedReader(steps
)
1448 func BenchmarkReaderCopyOptimal(b
*testing
.B
) {
1449 // Optimal case is where the underlying reader implements io.WriterTo
1450 srcBuf
:= bytes
.NewBuffer(make([]byte, 8192))
1451 src
:= NewReader(srcBuf
)
1452 dstBuf
:= new(bytes
.Buffer
)
1453 dst
:= onlyWriter
{dstBuf
}
1454 for i
:= 0; i
< b
.N
; i
++ {
1462 func BenchmarkReaderCopyUnoptimal(b
*testing
.B
) {
1463 // Unoptimal case is where the underlying reader doesn't implement io.WriterTo
1464 srcBuf
:= bytes
.NewBuffer(make([]byte, 8192))
1465 src
:= NewReader(onlyReader
{srcBuf
})
1466 dstBuf
:= new(bytes
.Buffer
)
1467 dst
:= onlyWriter
{dstBuf
}
1468 for i
:= 0; i
< b
.N
; i
++ {
1470 src
.Reset(onlyReader
{srcBuf
})
1476 func BenchmarkReaderCopyNoWriteTo(b
*testing
.B
) {
1477 srcBuf
:= bytes
.NewBuffer(make([]byte, 8192))
1478 srcReader
:= NewReader(srcBuf
)
1479 src
:= onlyReader
{srcReader
}
1480 dstBuf
:= new(bytes
.Buffer
)
1481 dst
:= onlyWriter
{dstBuf
}
1482 for i
:= 0; i
< b
.N
; i
++ {
1484 srcReader
.Reset(srcBuf
)
1490 func BenchmarkReaderWriteToOptimal(b
*testing
.B
) {
1491 const bufSize
= 16 << 10
1492 buf
:= make([]byte, bufSize
)
1493 r
:= bytes
.NewReader(buf
)
1494 srcReader
:= NewReaderSize(onlyReader
{r
}, 1<<10)
1495 if _
, ok
:= ioutil
.Discard
.(io
.ReaderFrom
); !ok
{
1496 b
.Fatal("ioutil.Discard doesn't support ReaderFrom")
1498 for i
:= 0; i
< b
.N
; i
++ {
1499 r
.Seek(0, io
.SeekStart
)
1500 srcReader
.Reset(onlyReader
{r
})
1501 n
, err
:= srcReader
.WriteTo(ioutil
.Discard
)
1506 b
.Fatalf("n = %d; want %d", n
, bufSize
)
1511 func BenchmarkWriterCopyOptimal(b
*testing
.B
) {
1512 // Optimal case is where the underlying writer implements io.ReaderFrom
1513 srcBuf
:= bytes
.NewBuffer(make([]byte, 8192))
1514 src
:= onlyReader
{srcBuf
}
1515 dstBuf
:= new(bytes
.Buffer
)
1516 dst
:= NewWriter(dstBuf
)
1517 for i
:= 0; i
< b
.N
; i
++ {
1525 func BenchmarkWriterCopyUnoptimal(b
*testing
.B
) {
1526 srcBuf
:= bytes
.NewBuffer(make([]byte, 8192))
1527 src
:= onlyReader
{srcBuf
}
1528 dstBuf
:= new(bytes
.Buffer
)
1529 dst
:= NewWriter(onlyWriter
{dstBuf
})
1530 for i
:= 0; i
< b
.N
; i
++ {
1533 dst
.Reset(onlyWriter
{dstBuf
})
1538 func BenchmarkWriterCopyNoReadFrom(b
*testing
.B
) {
1539 srcBuf
:= bytes
.NewBuffer(make([]byte, 8192))
1540 src
:= onlyReader
{srcBuf
}
1541 dstBuf
:= new(bytes
.Buffer
)
1542 dstWriter
:= NewWriter(dstBuf
)
1543 dst
:= onlyWriter
{dstWriter
}
1544 for i
:= 0; i
< b
.N
; i
++ {
1547 dstWriter
.Reset(dstBuf
)
1552 func BenchmarkReaderEmpty(b
*testing
.B
) {
1554 str
:= strings
.Repeat("x", 16<<10)
1555 for i
:= 0; i
< b
.N
; i
++ {
1556 br
:= NewReader(strings
.NewReader(str
))
1557 n
, err
:= io
.Copy(ioutil
.Discard
, br
)
1561 if n
!= int64(len(str
)) {
1562 b
.Fatal("wrong length")
1567 func BenchmarkWriterEmpty(b
*testing
.B
) {
1569 str
:= strings
.Repeat("x", 1<<10)
1571 for i
:= 0; i
< b
.N
; i
++ {
1572 bw
:= NewWriter(ioutil
.Discard
)
1585 func BenchmarkWriterFlush(b
*testing
.B
) {
1587 bw
:= NewWriter(ioutil
.Discard
)
1588 str
:= strings
.Repeat("x", 50)
1589 for i
:= 0; i
< b
.N
; i
++ {