1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
|
// 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"
"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) {
t.Skip("skipping on gccgo until we have escape analysis")
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())
}
}
// writerFunc is a Writer implemented by the underlying func.
type writerFunc func(p []byte) (int, error)
func (f writerFunc) Write(p []byte) (int, error) {
return f(p)
}
// Test that MultiWriter properly flattens chained multiWriters.
func TestMultiWriterSingleChainFlatten(t *testing.T) {
pc := make([]uintptr, 1000) // 1000 should fit the full stack
n := runtime.Callers(0, pc)
var myDepth = callDepth(pc[:n])
var writeDepth int // will contain the depth from which writerFunc.Writer was called
var w Writer = MultiWriter(writerFunc(func(p []byte) (int, error) {
n := runtime.Callers(1, pc)
writeDepth += callDepth(pc[:n])
return 0, nil
}))
mw := w
// chain a bunch of multiWriters
for i := 0; i < 100; i++ {
mw = MultiWriter(w)
}
mw = MultiWriter(w, mw, w, mw)
mw.Write(nil) // don't care about errors, just want to check the call-depth for Write
if writeDepth != 4*(myDepth+2) { // 2 should be multiWriter.Write and writerFunc.Write
t.Errorf("multiWriter did not flatten chained multiWriters: expected writeDepth %d, got %d",
4*(myDepth+2), writeDepth)
}
}
func TestMultiWriterError(t *testing.T) {
f1 := writerFunc(func(p []byte) (int, error) {
return len(p) / 2, ErrShortWrite
})
f2 := writerFunc(func(p []byte) (int, error) {
t.Errorf("MultiWriter called f2.Write")
return len(p), nil
})
w := MultiWriter(f1, f2)
n, err := w.Write(make([]byte, 100))
if n != 50 || err != ErrShortWrite {
t.Errorf("Write = %d, %v, want 50, ErrShortWrite", n, err)
}
}
// 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 := 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 a 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 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 := 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 a 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) {
if runtime.Compiler == "gccgo" {
t.Skip("skipping finalizer test on gccgo with conservative GC")
}
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)
}
}
|