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