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
|
package buffer
import (
"io"
"testing"
)
func TestWrite(t *testing.T) {
b := Buffer{}
data := []byte("test")
n, err := b.Write(data)
if n != len(data) || err != nil {
t.Errorf("Write failed: expected %d bytes, got %d, error: %v", len(data), n, err)
}
if b.Len() != len(data) {
t.Errorf("Len is incorrect after write: expected %d, got %d", len(data), b.Len())
}
if string(b.Bytes()) != "test" {
t.Error("Bytes returned after write do not match written data")
}
}
func TestRead(t *testing.T) {
b := NewBuffer([]byte("testdata"))
p := make([]byte, 3)
n, err := b.Read(p)
if n != 3 || string(p[:n]) != "tes" {
t.Errorf("Read returned incorrect data: expected 'tes', got '%s'", p[:n])
}
b.Reset()
b.Write([]byte("abc"))
p = make([]byte, 2)
n, err = b.Read(p)
if n != 2 || string(p) != "ab" {
t.Errorf("Read after reset failed: expected 'ab', got '%s'", p)
}
b.pos = b.len
n, err = b.Read(p)
if n != 0 || err != io.EOF {
t.Errorf("Reading beyond buffer did not return EOF: n=%d, err=%v", n, err)
}
}
func TestReset(t *testing.T) {
b := NewBuffer([]byte("test"))
b.Write([]byte("data"))
if b.Len() != 8 || b.pos != 0 {
t.Errorf("Initial buffer state incorrect: len=%d, pos=%d", b.Len(), b.pos)
}
b.Reset()
if b.Len() != 0 || b.pos != 0 {
t.Errorf("Reset did not clear buffer correctly: len=%d, pos=%d", b.Len(), b.pos)
}
}
func TestSeek(t *testing.T) {
b := NewBuffer([]byte("test"))
tests := []struct {
offset int64
whence int
expect int64
err error
}{
{2, io.SeekStart, 2, nil},
{-1, io.SeekCurrent, 1, nil},
{-2, io.SeekEnd, int64(len("test") - 2), nil},
{5, io.SeekStart, int64(len("test")), nil},
{-10, io.SeekEnd, 0, nil},
{0, 999, 0, io.EOF}, // Invalid whence test
}
for _, tt := range tests {
pos, err := b.Seek(tt.offset, tt.whence)
if pos != tt.expect || (err != tt.err && !((err == nil) && (tt.err == nil))) {
t.Errorf("Seek(%d, %d): expected %d with error %v, got %d and %v",
tt.offset, tt.whence, tt.expect, tt.err, pos, err)
}
}
}
|