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
:= strings
.NewReader("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
: "strings.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
:= strings
.NewReader("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
:= strings
.NewReader("0123456789")
82 {0, 10, "0123456789", nil},
83 {1, 10, "123456789", io
.EOF
},
84 {1, 9, "123456789", nil},
87 {-1, 0, "", "strings.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
:= strings
.NewReader("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
:= strings
.NewReader("")
123 var wg sync
.WaitGroup
124 for i
:= 0; i
< 5; i
++ {
139 func TestWriteTo(t
*testing
.T
) {
140 const str
= "0123456789"
141 for i
:= 0; i
<= len(str
); i
++ {
143 r
:= strings
.NewReader(s
)
145 n
, err
:= r
.WriteTo(&b
)
146 if expect
:= int64(len(s
)); n
!= expect
{
147 t
.Errorf("got %v; want %v", n
, expect
)
150 t
.Errorf("for length %d: got error = %v; want nil", len(s
), err
)
153 t
.Errorf("got string %q; want %q", b
.String(), s
)
156 t
.Errorf("reader contains %v bytes; want 0", r
.Len())
161 // tests that Len is affected by reads, but Size is not.
162 func TestReaderLenSize(t
*testing
.T
) {
163 r
:= strings
.NewReader("abc")
164 io
.CopyN(io
.Discard
, r
, 1)
166 t
.Errorf("Len = %d; want 2", r
.Len())
169 t
.Errorf("Size = %d; want 3", r
.Size())
173 func TestReaderReset(t
*testing
.T
) {
174 r
:= strings
.NewReader("世界")
175 if _
, _
, err
:= r
.ReadRune(); err
!= nil {
176 t
.Errorf("ReadRune: unexpected error: %v", err
)
179 const want
= "abcdef"
181 if err
:= r
.UnreadRune(); err
== nil {
182 t
.Errorf("UnreadRune: expected error, got nil")
184 buf
, err
:= io
.ReadAll(r
)
186 t
.Errorf("ReadAll: unexpected error: %v", err
)
188 if got
:= string(buf
); got
!= want
{
189 t
.Errorf("ReadAll: got %q, want %q", got
, want
)
193 func TestReaderZero(t
*testing
.T
) {
194 if l
:= (&strings
.Reader
{}).Len(); l
!= 0 {
195 t
.Errorf("Len: got %d, want 0", l
)
198 if n
, err
:= (&strings
.Reader
{}).Read(nil); n
!= 0 || err
!= io
.EOF
{
199 t
.Errorf("Read: got %d, %v; want 0, io.EOF", n
, err
)
202 if n
, err
:= (&strings
.Reader
{}).ReadAt(nil, 11); n
!= 0 || err
!= io
.EOF
{
203 t
.Errorf("ReadAt: got %d, %v; want 0, io.EOF", n
, err
)
206 if b
, err
:= (&strings
.Reader
{}).ReadByte(); b
!= 0 || err
!= io
.EOF
{
207 t
.Errorf("ReadByte: got %d, %v; want 0, io.EOF", b
, err
)
210 if ch
, size
, err
:= (&strings
.Reader
{}).ReadRune(); ch
!= 0 || size
!= 0 || err
!= io
.EOF
{
211 t
.Errorf("ReadRune: got %d, %d, %v; want 0, 0, io.EOF", ch
, size
, err
)
214 if offset
, err
:= (&strings
.Reader
{}).Seek(11, io
.SeekStart
); offset
!= 11 || err
!= nil {
215 t
.Errorf("Seek: got %d, %v; want 11, nil", offset
, err
)
218 if s
:= (&strings
.Reader
{}).Size(); s
!= 0 {
219 t
.Errorf("Size: got %d, want 0", s
)
222 if (&strings
.Reader
{}).UnreadByte() == nil {
223 t
.Errorf("UnreadByte: got nil, want error")
226 if (&strings
.Reader
{}).UnreadRune() == nil {
227 t
.Errorf("UnreadRune: got nil, want error")
230 if n
, err
:= (&strings
.Reader
{}).WriteTo(io
.Discard
); n
!= 0 || err
!= nil {
231 t
.Errorf("WriteTo: got %d, %v; want 0, nil", n
, err
)