1 // Copyright 2012 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.
16 func TestReader(t
*testing
.T
) {
17 r
:= NewReader([]byte("0123456789"))
27 {seek
: io
.SeekStart
, off
: 0, n
: 20, want
: "0123456789"},
28 {seek
: io
.SeekStart
, off
: 1, n
: 1, want
: "1"},
29 {seek
: io
.SeekCurrent
, off
: 1, wantpos
: 3, n
: 2, want
: "34"},
30 {seek
: io
.SeekStart
, off
: -1, seekerr
: "bytes.Reader.Seek: negative position"},
31 {seek
: io
.SeekStart
, off
: 1 << 33, wantpos
: 1 << 33, readerr
: io
.EOF
},
32 {seek
: io
.SeekCurrent
, off
: 1, wantpos
: 1<<33 + 1, readerr
: io
.EOF
},
33 {seek
: io
.SeekStart
, n
: 5, want
: "01234"},
34 {seek
: io
.SeekCurrent
, n
: 5, want
: "56789"},
35 {seek
: io
.SeekEnd
, off
: -1, n
: 1, wantpos
: 9, want
: "9"},
38 for i
, tt
:= range tests
{
39 pos
, err
:= r
.Seek(tt
.off
, tt
.seek
)
40 if err
== nil && tt
.seekerr
!= "" {
41 t
.Errorf("%d. want seek error %q", i
, tt
.seekerr
)
44 if err
!= nil && err
.Error() != tt
.seekerr
{
45 t
.Errorf("%d. seek error = %q; want %q", i
, err
.Error(), tt
.seekerr
)
48 if tt
.wantpos
!= 0 && tt
.wantpos
!= pos
{
49 t
.Errorf("%d. pos = %d, want %d", i
, pos
, tt
.wantpos
)
51 buf
:= make([]byte, tt
.n
)
53 if err
!= tt
.readerr
{
54 t
.Errorf("%d. read = %v; want %v", i
, err
, tt
.readerr
)
57 got
:= string(buf
[:n
])
59 t
.Errorf("%d. got %q; want %q", i
, got
, tt
.want
)
64 func TestReadAfterBigSeek(t
*testing
.T
) {
65 r
:= NewReader([]byte("0123456789"))
66 if _
, err
:= r
.Seek(1<<31+5, io
.SeekStart
); err
!= nil {
69 if n
, err
:= r
.Read(make([]byte, 10)); n
!= 0 || err
!= io
.EOF
{
70 t
.Errorf("Read = %d, %v; want 0, EOF", n
, err
)
74 func TestReaderAt(t
*testing
.T
) {
75 r
:= NewReader([]byte("0123456789"))
82 {0, 10, "0123456789", nil},
83 {1, 10, "123456789", io
.EOF
},
84 {1, 9, "123456789", nil},
87 {-1, 0, "", "bytes.Reader.ReadAt: negative offset"},
89 for i
, tt
:= range tests
{
90 b
:= make([]byte, tt
.n
)
91 rn
, err
:= r
.ReadAt(b
, tt
.off
)
94 t
.Errorf("%d. got %q; want %q", i
, got
, tt
.want
)
96 if fmt
.Sprintf("%v", err
) != fmt
.Sprintf("%v", tt
.wanterr
) {
97 t
.Errorf("%d. got error = %v; want %v", i
, err
, tt
.wanterr
)
102 func TestReaderAtConcurrent(t
*testing
.T
) {
103 // Test for the race detector, to verify ReadAt doesn't mutate
105 r
:= NewReader([]byte("0123456789"))
106 var wg sync
.WaitGroup
107 for i
:= 0; i
< 5; i
++ {
112 r
.ReadAt(buf
[:], int64(i
))
118 func TestEmptyReaderConcurrent(t
*testing
.T
) {
119 // Test for the race detector, to verify a Read that doesn't yield any bytes
120 // is okay to use from multiple goroutines. This was our historic behavior.
121 // See golang.org/issue/7856
122 r
:= NewReader([]byte{})
123 var wg sync
.WaitGroup
124 for i
:= 0; i
< 5; i
++ {
139 func TestReaderWriteTo(t
*testing
.T
) {
140 for i
:= 0; i
< 30; i
+= 3 {
143 l
= len(testString
) / i
146 r
:= NewReader(testBytes
[:l
])
148 n
, err
:= r
.WriteTo(&b
)
149 if expect
:= int64(len(s
)); n
!= expect
{
150 t
.Errorf("got %v; want %v", n
, expect
)
153 t
.Errorf("for length %d: got error = %v; want nil", l
, err
)
156 t
.Errorf("got string %q; want %q", b
.String(), s
)
159 t
.Errorf("reader contains %v bytes; want 0", r
.Len())
164 func TestReaderLen(t
*testing
.T
) {
165 const data
= "hello world"
166 r
:= NewReader([]byte(data
))
167 if got
, want
:= r
.Len(), 11; got
!= want
{
168 t
.Errorf("r.Len(): got %d, want %d", got
, want
)
170 if n
, err
:= r
.Read(make([]byte, 10)); err
!= nil || n
!= 10 {
171 t
.Errorf("Read failed: read %d %v", n
, err
)
173 if got
, want
:= r
.Len(), 1; got
!= want
{
174 t
.Errorf("r.Len(): got %d, want %d", got
, want
)
176 if n
, err
:= r
.Read(make([]byte, 1)); err
!= nil || n
!= 1 {
177 t
.Errorf("Read failed: read %d %v; want 1, nil", n
, err
)
179 if got
, want
:= r
.Len(), 0; got
!= want
{
180 t
.Errorf("r.Len(): got %d, want %d", got
, want
)
184 var UnreadRuneErrorTests
= []struct {
188 {"Read", func(r
*Reader
) { r
.Read([]byte{0}) }},
189 {"ReadByte", func(r
*Reader
) { r
.ReadByte() }},
190 {"UnreadRune", func(r
*Reader
) { r
.UnreadRune() }},
191 {"Seek", func(r
*Reader
) { r
.Seek(0, io
.SeekCurrent
) }},
192 {"WriteTo", func(r
*Reader
) { r
.WriteTo(&Buffer
{}) }},
195 func TestUnreadRuneError(t
*testing
.T
) {
196 for _
, tt
:= range UnreadRuneErrorTests
{
197 reader
:= NewReader([]byte("0123456789"))
198 if _
, _
, err
:= reader
.ReadRune(); err
!= nil {
203 err
:= reader
.UnreadRune()
205 t
.Errorf("Unreading after %s: expected error", tt
.name
)
210 func TestReaderDoubleUnreadRune(t
*testing
.T
) {
211 buf
:= NewBuffer([]byte("groucho"))
212 if _
, _
, err
:= buf
.ReadRune(); err
!= nil {
216 if err
:= buf
.UnreadByte(); err
!= nil {
220 if err
:= buf
.UnreadByte(); err
== nil {
221 t
.Fatal("UnreadByte: expected error, got nil")
225 // verify that copying from an empty reader always has the same results,
226 // regardless of the presence of a WriteTo method.
227 func TestReaderCopyNothing(t
*testing
.T
) {
232 type justReader
struct {
235 type justWriter
struct {
238 discard
:= justWriter
{ioutil
.Discard
} // hide ReadFrom
240 var with
, withOut nErr
241 with
.n
, with
.err
= io
.Copy(discard
, NewReader(nil))
242 withOut
.n
, withOut
.err
= io
.Copy(discard
, justReader
{NewReader(nil)})
244 t
.Errorf("behavior differs: with = %#v; without: %#v", with
, withOut
)
248 // tests that Len is affected by reads, but Size is not.
249 func TestReaderLenSize(t
*testing
.T
) {
250 r
:= NewReader([]byte("abc"))
251 io
.CopyN(ioutil
.Discard
, r
, 1)
253 t
.Errorf("Len = %d; want 2", r
.Len())
256 t
.Errorf("Size = %d; want 3", r
.Size())
260 func TestReaderReset(t
*testing
.T
) {
261 r
:= NewReader([]byte("世界"))
262 if _
, _
, err
:= r
.ReadRune(); err
!= nil {
263 t
.Errorf("ReadRune: unexpected error: %v", err
)
266 const want
= "abcdef"
267 r
.Reset([]byte(want
))
268 if err
:= r
.UnreadRune(); err
== nil {
269 t
.Errorf("UnreadRune: expected error, got nil")
271 buf
, err
:= ioutil
.ReadAll(r
)
273 t
.Errorf("ReadAll: unexpected error: %v", err
)
275 if got
:= string(buf
); got
!= want
{
276 t
.Errorf("ReadAll: got %q, want %q", got
, want
)