| // Copyright 2010 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package io_test |
| |
| import ( |
| "bytes" |
| "crypto/sha1" |
| "errors" |
| "fmt" |
| . "io" |
| "io/ioutil" |
| "runtime" |
| "strings" |
| "testing" |
| "time" |
| ) |
| |
| func TestMultiReader(t *testing.T) { |
| var mr Reader |
| var buf []byte |
| nread := 0 |
| withFooBar := func(tests func()) { |
| r1 := strings.NewReader("foo ") |
| r2 := strings.NewReader("") |
| r3 := strings.NewReader("bar") |
| mr = MultiReader(r1, r2, r3) |
| buf = make([]byte, 20) |
| tests() |
| } |
| expectRead := func(size int, expected string, eerr error) { |
| nread++ |
| n, gerr := mr.Read(buf[0:size]) |
| if n != len(expected) { |
| t.Errorf("#%d, expected %d bytes; got %d", |
| nread, len(expected), n) |
| } |
| got := string(buf[0:n]) |
| if got != expected { |
| t.Errorf("#%d, expected %q; got %q", |
| nread, expected, got) |
| } |
| if gerr != eerr { |
| t.Errorf("#%d, expected error %v; got %v", |
| nread, eerr, gerr) |
| } |
| buf = buf[n:] |
| } |
| withFooBar(func() { |
| expectRead(2, "fo", nil) |
| expectRead(5, "o ", nil) |
| expectRead(5, "bar", nil) |
| expectRead(5, "", EOF) |
| }) |
| withFooBar(func() { |
| expectRead(4, "foo ", nil) |
| expectRead(1, "b", nil) |
| expectRead(3, "ar", nil) |
| expectRead(1, "", EOF) |
| }) |
| withFooBar(func() { |
| expectRead(5, "foo ", nil) |
| }) |
| } |
| |
| func TestMultiWriter(t *testing.T) { |
| sink := new(bytes.Buffer) |
| // Hide bytes.Buffer's WriteString method: |
| testMultiWriter(t, struct { |
| Writer |
| fmt.Stringer |
| }{sink, sink}) |
| } |
| |
| func TestMultiWriter_String(t *testing.T) { |
| testMultiWriter(t, new(bytes.Buffer)) |
| } |
| |
| // test that a multiWriter.WriteString calls results in at most 1 allocation, |
| // even if multiple targets don't support WriteString. |
| func TestMultiWriter_WriteStringSingleAlloc(t *testing.T) { |
| var sink1, sink2 bytes.Buffer |
| type simpleWriter struct { // hide bytes.Buffer's WriteString |
| Writer |
| } |
| mw := MultiWriter(simpleWriter{&sink1}, simpleWriter{&sink2}) |
| allocs := int(testing.AllocsPerRun(1000, func() { |
| WriteString(mw, "foo") |
| })) |
| if allocs != 1 { |
| t.Errorf("num allocations = %d; want 1", allocs) |
| } |
| } |
| |
| type writeStringChecker struct{ called bool } |
| |
| func (c *writeStringChecker) WriteString(s string) (n int, err error) { |
| c.called = true |
| return len(s), nil |
| } |
| |
| func (c *writeStringChecker) Write(p []byte) (n int, err error) { |
| return len(p), nil |
| } |
| |
| func TestMultiWriter_StringCheckCall(t *testing.T) { |
| var c writeStringChecker |
| mw := MultiWriter(&c) |
| WriteString(mw, "foo") |
| if !c.called { |
| t.Error("did not see WriteString call to writeStringChecker") |
| } |
| } |
| |
| func testMultiWriter(t *testing.T, sink interface { |
| Writer |
| fmt.Stringer |
| }) { |
| sha1 := sha1.New() |
| mw := MultiWriter(sha1, sink) |
| |
| sourceString := "My input text." |
| source := strings.NewReader(sourceString) |
| written, err := Copy(mw, source) |
| |
| if written != int64(len(sourceString)) { |
| t.Errorf("short write of %d, not %d", written, len(sourceString)) |
| } |
| |
| if err != nil { |
| t.Errorf("unexpected error: %v", err) |
| } |
| |
| sha1hex := fmt.Sprintf("%x", sha1.Sum(nil)) |
| if sha1hex != "01cb303fa8c30a64123067c5aa6284ba7ec2d31b" { |
| t.Error("incorrect sha1 value") |
| } |
| |
| if sink.String() != sourceString { |
| t.Errorf("expected %q; got %q", sourceString, sink.String()) |
| } |
| } |
| |
| // Test that MultiReader copies the input slice and is insulated from future modification. |
| func TestMultiReaderCopy(t *testing.T) { |
| slice := []Reader{strings.NewReader("hello world")} |
| r := MultiReader(slice...) |
| slice[0] = nil |
| data, err := ioutil.ReadAll(r) |
| if err != nil || string(data) != "hello world" { |
| t.Errorf("ReadAll() = %q, %v, want %q, nil", data, err, "hello world") |
| } |
| } |
| |
| // Test that MultiWriter copies the input slice and is insulated from future modification. |
| func TestMultiWriterCopy(t *testing.T) { |
| var buf bytes.Buffer |
| slice := []Writer{&buf} |
| w := MultiWriter(slice...) |
| slice[0] = nil |
| n, err := w.Write([]byte("hello world")) |
| if err != nil || n != 11 { |
| t.Errorf("Write(`hello world`) = %d, %v, want 11, nil", n, err) |
| } |
| if buf.String() != "hello world" { |
| t.Errorf("buf.String() = %q, want %q", buf.String(), "hello world") |
| } |
| } |
| |
| // readerFunc is an io.Reader implemented by the underlying func. |
| type readerFunc func(p []byte) (int, error) |
| |
| func (f readerFunc) Read(p []byte) (int, error) { |
| return f(p) |
| } |
| |
| // callDepth returns the logical call depth for the given PCs. |
| func callDepth(callers []uintptr) (depth int) { |
| frames := runtime.CallersFrames(callers) |
| more := true |
| for more { |
| _, more = frames.Next() |
| depth++ |
| } |
| return |
| } |
| |
| // Test that MultiReader properly flattens chained multiReaders when Read is called |
| func TestMultiReaderFlatten(t *testing.T) { |
| pc := make([]uintptr, 1000) // 1000 should fit the full stack |
| n := runtime.Callers(0, pc) |
| var myDepth = callDepth(pc[:n]) |
| var readDepth int // will contain the depth from which fakeReader.Read was called |
| var r Reader = MultiReader(readerFunc(func(p []byte) (int, error) { |
| n := runtime.Callers(1, pc) |
| readDepth = callDepth(pc[:n]) |
| return 0, errors.New("irrelevant") |
| })) |
| |
| // chain a bunch of multiReaders |
| for i := 0; i < 100; i++ { |
| r = MultiReader(r) |
| } |
| |
| r.Read(nil) // don't care about errors, just want to check the call-depth for Read |
| |
| if readDepth != myDepth+2 { // 2 should be multiReader.Read and fakeReader.Read |
| t.Errorf("multiReader did not flatten chained multiReaders: expected readDepth %d, got %d", |
| myDepth+2, readDepth) |
| } |
| } |
| |
| // byteAndEOFReader is a Reader which reads one byte (the underlying |
| // byte) and io.EOF at once in its Read call. |
| type byteAndEOFReader byte |
| |
| func (b byteAndEOFReader) Read(p []byte) (n int, err error) { |
| if len(p) == 0 { |
| // Read(0 bytes) is useless. We expect no such useless |
| // calls in this test. |
| panic("unexpected call") |
| } |
| p[0] = byte(b) |
| return 1, EOF |
| } |
| |
| // This used to yield bytes forever; issue 16795. |
| func TestMultiReaderSingleByteWithEOF(t *testing.T) { |
| got, err := ioutil.ReadAll(LimitReader(MultiReader(byteAndEOFReader('a'), byteAndEOFReader('b')), 10)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| const want = "ab" |
| if string(got) != want { |
| t.Errorf("got %q; want %q", got, want) |
| } |
| } |
| |
| // Test that a reader returning (n, EOF) at the end of an MultiReader |
| // chain continues to return EOF on its final read, rather than |
| // yielding a (0, EOF). |
| func TestMultiReaderFinalEOF(t *testing.T) { |
| r := MultiReader(bytes.NewReader(nil), byteAndEOFReader('a')) |
| buf := make([]byte, 2) |
| n, err := r.Read(buf) |
| if n != 1 || err != EOF { |
| t.Errorf("got %v, %v; want 1, EOF", n, err) |
| } |
| } |
| |
| func TestMultiReaderFreesExhaustedReaders(t *testing.T) { |
| var mr Reader |
| closed := make(chan struct{}) |
| // The closure ensures that we don't have a live reference to buf1 |
| // on our stack after MultiReader is inlined (Issue 18819). This |
| // is a work around for a limitation in liveness analysis. |
| func() { |
| buf1 := bytes.NewReader([]byte("foo")) |
| buf2 := bytes.NewReader([]byte("bar")) |
| mr = MultiReader(buf1, buf2) |
| runtime.SetFinalizer(buf1, func(*bytes.Reader) { |
| close(closed) |
| }) |
| }() |
| |
| buf := make([]byte, 4) |
| if n, err := ReadFull(mr, buf); err != nil || string(buf) != "foob" { |
| t.Fatalf(`ReadFull = %d (%q), %v; want 3, "foo", nil`, n, buf[:n], err) |
| } |
| |
| runtime.GC() |
| select { |
| case <-closed: |
| case <-time.After(5 * time.Second): |
| t.Fatal("timeout waiting for collection of buf1") |
| } |
| |
| if n, err := ReadFull(mr, buf[:2]); err != nil || string(buf[:2]) != "ar" { |
| t.Fatalf(`ReadFull = %d (%q), %v; want 2, "ar", nil`, n, buf[:n], err) |
| } |
| } |
| |
| func TestInterleavedMultiReader(t *testing.T) { |
| r1 := strings.NewReader("123") |
| r2 := strings.NewReader("45678") |
| |
| mr1 := MultiReader(r1, r2) |
| mr2 := MultiReader(mr1) |
| |
| buf := make([]byte, 4) |
| |
| // Have mr2 use mr1's []Readers. |
| // Consume r1 (and clear it for GC to handle) and consume part of r2. |
| n, err := ReadFull(mr2, buf) |
| if got := string(buf[:n]); got != "1234" || err != nil { |
| t.Errorf(`ReadFull(mr2) = (%q, %v), want ("1234", nil)`, got, err) |
| } |
| |
| // Consume the rest of r2 via mr1. |
| // This should not panic even though mr2 cleared r1. |
| n, err = ReadFull(mr1, buf) |
| if got := string(buf[:n]); got != "5678" || err != nil { |
| t.Errorf(`ReadFull(mr1) = (%q, %v), want ("5678", nil)`, got, err) |
| } |
| } |