← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/io/io_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/io/io_test.go
6
6
 
7
7
import (
8
8
        "bytes"
 
9
        "errors"
 
10
        "fmt"
9
11
        . "io"
10
12
        "strings"
11
13
        "testing"
88
90
        return w.w.Write(p)
89
91
}
90
92
 
 
93
type wantedAndErrReader struct{}
 
94
 
 
95
func (wantedAndErrReader) Read(p []byte) (int, error) {
 
96
        return len(p), errors.New("wantedAndErrReader error")
 
97
}
 
98
 
91
99
func TestCopyNEOF(t *testing.T) {
92
100
        // Test that EOF behavior is the same regardless of whether
93
101
        // argument to CopyN has ReadFrom.
113
121
        if n != 3 || err != EOF {
114
122
                t.Errorf("CopyN(bytes.Buffer, foo, 4) = %d, %v; want 3, EOF", n, err)
115
123
        }
 
124
 
 
125
        n, err = CopyN(b, wantedAndErrReader{}, 5)
 
126
        if n != 5 || err != nil {
 
127
                t.Errorf("CopyN(bytes.Buffer, wantedAndErrReader, 5) = %d, %v; want 5, nil", n, err)
 
128
        }
 
129
 
 
130
        n, err = CopyN(&noReadFrom{b}, wantedAndErrReader{}, 5)
 
131
        if n != 5 || err != nil {
 
132
                t.Errorf("CopyN(noReadFrom, wantedAndErrReader, 5) = %d, %v; want 5, nil", n, err)
 
133
        }
116
134
}
117
135
 
118
136
func TestReadAtLeast(t *testing.T) {
120
138
        testReadAtLeast(t, &rb)
121
139
}
122
140
 
123
 
// A version of bytes.Buffer that returns n > 0, EOF on Read
 
141
// A version of bytes.Buffer that returns n > 0, err on Read
124
142
// when the input is exhausted.
125
 
type dataAndEOFBuffer struct {
 
143
type dataAndErrorBuffer struct {
 
144
        err error
126
145
        bytes.Buffer
127
146
}
128
147
 
129
 
func (r *dataAndEOFBuffer) Read(p []byte) (n int, err error) {
 
148
func (r *dataAndErrorBuffer) Read(p []byte) (n int, err error) {
130
149
        n, err = r.Buffer.Read(p)
131
150
        if n > 0 && r.Buffer.Len() == 0 && err == nil {
132
 
                err = EOF
 
151
                err = r.err
133
152
        }
134
153
        return
135
154
}
136
155
 
137
156
func TestReadAtLeastWithDataAndEOF(t *testing.T) {
138
 
        var rb dataAndEOFBuffer
 
157
        var rb dataAndErrorBuffer
 
158
        rb.err = EOF
 
159
        testReadAtLeast(t, &rb)
 
160
}
 
161
 
 
162
func TestReadAtLeastWithDataAndError(t *testing.T) {
 
163
        var rb dataAndErrorBuffer
 
164
        rb.err = fmt.Errorf("fake error")
139
165
        testReadAtLeast(t, &rb)
140
166
}
141
167
 
169
195
        }
170
196
        rb.Write([]byte("4"))
171
197
        n, err = ReadAtLeast(rb, buf, 2)
172
 
        if err != ErrUnexpectedEOF {
173
 
                t.Errorf("expected ErrUnexpectedEOF, got %v", err)
 
198
        want := ErrUnexpectedEOF
 
199
        if rb, ok := rb.(*dataAndErrorBuffer); ok && rb.err != EOF {
 
200
                want = rb.err
 
201
        }
 
202
        if err != want {
 
203
                t.Errorf("expected %v, got %v", want, err)
174
204
        }
175
205
        if n != 1 {
176
206
                t.Errorf("expected to have read 1 bytes, got %v", n)
203
233
                t.Errorf("closed tee: ReadFull(r, dst) = %d, %v; want 0, EPIPE", n, err)
204
234
        }
205
235
}
 
236
 
 
237
func TestSectionReader_ReadAt(tst *testing.T) {
 
238
        dat := "a long sample data, 1234567890"
 
239
        tests := []struct {
 
240
                data   string
 
241
                off    int
 
242
                n      int
 
243
                bufLen int
 
244
                at     int
 
245
                exp    string
 
246
                err    error
 
247
        }{
 
248
                {data: "", off: 0, n: 10, bufLen: 2, at: 0, exp: "", err: EOF},
 
249
                {data: dat, off: 0, n: len(dat), bufLen: 0, at: 0, exp: "", err: nil},
 
250
                {data: dat, off: len(dat), n: 1, bufLen: 1, at: 0, exp: "", err: EOF},
 
251
                {data: dat, off: 0, n: len(dat) + 2, bufLen: len(dat), at: 0, exp: dat, err: nil},
 
252
                {data: dat, off: 0, n: len(dat), bufLen: len(dat) / 2, at: 0, exp: dat[:len(dat)/2], err: nil},
 
253
                {data: dat, off: 0, n: len(dat), bufLen: len(dat), at: 0, exp: dat, err: nil},
 
254
                {data: dat, off: 0, n: len(dat), bufLen: len(dat) / 2, at: 2, exp: dat[2 : 2+len(dat)/2], err: nil},
 
255
                {data: dat, off: 3, n: len(dat), bufLen: len(dat) / 2, at: 2, exp: dat[5 : 5+len(dat)/2], err: nil},
 
256
                {data: dat, off: 3, n: len(dat) / 2, bufLen: len(dat)/2 - 2, at: 2, exp: dat[5 : 5+len(dat)/2-2], err: nil},
 
257
                {data: dat, off: 3, n: len(dat) / 2, bufLen: len(dat)/2 + 2, at: 2, exp: dat[5 : 5+len(dat)/2-2], err: EOF},
 
258
        }
 
259
        for i, t := range tests {
 
260
                r := strings.NewReader(t.data)
 
261
                s := NewSectionReader(r, int64(t.off), int64(t.n))
 
262
                buf := make([]byte, t.bufLen)
 
263
                if n, err := s.ReadAt(buf, int64(t.at)); n != len(t.exp) || string(buf[:n]) != t.exp || err != t.err {
 
264
                        tst.Fatalf("%d: ReadAt(%d) = %q, %v; expected %q, %v", i, t.at, buf[:n], err, t.exp, t.err)
 
265
                }
 
266
        }
 
267
}