Debian Codegraph @

sbuf/sbuf_test.go

raw
1 package sbuf
2
3 import (
4 "bytes"
5 "crypto/rand"
6 "testing"
7
8 "golang.org/x/crypto/nacl/box"
9 )
10
11 var (
12 buf = &Buffer{}
13 testMessage1 = []byte("round and round and round we go, where we stop, no one knows")
14 testMessage2 = []byte("the deconstruction of falling stars")
15 )
16
17 func TestWrite(t *testing.T) {
18 n, err := buf.Write(testMessage1)
19 if err != nil {
20 t.Fatalf("%v", err)
21 }
22
23 if n != len(testMessage1) {
24 t.Fatalf("expected to write %d bytes, but only wrote %d bytes", len(testMessage1), n)
25 }
26
27 if buf.Len() != len(testMessage1) {
28 t.Fatalf("expected a length of %d, but have a length of %d", len(testMessage1), buf.Len())
29 }
30
31 if buf.Cap() != (len(testMessage1) * 2) {
32 t.Fatalf("expected a capacity of %d, but have a capacity of %d", len(testMessage1)*2, buf.Cap())
33 }
34
35 n, err = buf.Write(testMessage2)
36 if err != nil {
37 t.Fatalf("%v", err)
38 }
39
40 if n != len(testMessage2) {
41 t.Fatalf("expected to write %d bytes, but only wrote %d bytes", len(testMessage2), n)
42 }
43
44 n, err = buf.Write(testMessage2)
45 if err != nil {
46 t.Fatalf("%v", err)
47 }
48
49 if n != len(testMessage2) {
50 t.Fatalf("expected to write %d bytes, but only wrote %d bytes", len(testMessage2), n)
51 }
52 }
53
54 func TestRead(t *testing.T) {
55 var p = make([]byte, len(testMessage1))
56 n, err := buf.Read(p)
57 if err != nil {
58 t.Fatalf("%v", err)
59 }
60
61 if n != len(testMessage1) {
62 t.Fatalf("expected to read %d bytes, but only read %d bytes", len(testMessage1), n)
63 }
64
65 if !bytes.Equal(p, testMessage1) {
66 t.Fatalf("expected p='%s', but p='%s'", testMessage1, p)
67 }
68
69 p = make([]byte, len(testMessage2))
70 n, err = buf.Read(p)
71 if err != nil {
72 t.Fatalf("%v", err)
73 }
74
75 if n != len(testMessage2) {
76 t.Fatalf("expected to read %d bytes, but only read %d bytes", len(testMessage2), n)
77 }
78
79 if !bytes.Equal(p, testMessage2) {
80 t.Fatalf("expected p='%s', but p='%s'", testMessage2, p)
81 }
82
83 buf.Close()
84 n, err = buf.Read(p)
85 if err == nil {
86 t.Fatal("expected EOF")
87 } else if n != 0 {
88 t.Fatalf("expect n=0, but n=%d", n)
89 }
90
91 p = nil
92 n, err = buf.Read(p)
93 if err != nil {
94 t.Fatalf("%v", err)
95 } else if n != 0 {
96 t.Fatalf("expect n=0, but n=%d", n)
97 }
98 }
99
100 func TestShortRead(t *testing.T) {
101 tmpMessage := []byte("hello, world")
102 buf.Write(tmpMessage)
103
104 var p = make([]byte, len(testMessage1))
105 n, err := buf.Read(p)
106 if err != nil {
107 t.Fatalf("%v", err)
108 }
109
110 if n != len(tmpMessage) {
111 t.Fatalf("expected to read %d bytes, but only read %d bytes", len(testMessage1), n)
112 }
113 }
114
115 func TestNewBuffer(t *testing.T) {
116 buf := NewBuffer(32)
117 if len(buf.buf) != 0 {
118 t.Fatalf("expected new buffer length to be 0, have %d",
119 len(buf.buf))
120 }
121
122 if cap(buf.buf) != 32 {
123 t.Fatalf("expected new buffer capacity to be 0, have %d",
124 cap(buf.buf))
125 }
126 }
127
128 func TestNewBufferFrom(t *testing.T) {
129 p := make([]byte, len(testMessage1))
130 copy(p, testMessage1)
131 buf := NewBufferFrom(p)
132 if !bytes.Equal(buf.buf, testMessage1) {
133 t.Fatal("new buffer wasn't constructed properly")
134 }
135 }
136
137 func TestBytes(t *testing.T) {
138 p := make([]byte, len(testMessage1))
139 copy(p, testMessage1)
140 buf := NewBufferFrom(p)
141
142 out := buf.Bytes()
143 if buf.buf != nil {
144 t.Fatal("buffer was not closed")
145 }
146
147 if !bytes.Equal(out, testMessage1) {
148 t.Fatal("buffer did not return the right data")
149 }
150
151 out = buf.Bytes()
152 if out != nil {
153 t.Fatal("a closed buffer should return nil for Bytes")
154 }
155 }
156
157 func TestRWByte(t *testing.T) {
158 buf := NewBuffer(0)
159 c := byte(42)
160 err := buf.WriteByte(c)
161 if err != nil {
162 t.Fatalf("%v", err)
163 }
164
165 c, err = buf.ReadByte()
166 if err != nil {
167 t.Fatalf("%v", err)
168 }
169
170 if c != 42 {
171 t.Fatal("Expected 42, have %d", c)
172 }
173
174 _, err = buf.ReadByte()
175 if err == nil {
176 t.Fatal("Expected EOF")
177 }
178 }
179
180 func BenchmarkRead(b *testing.B) {
181 b.N = 2000
182 pub, priv, err := box.GenerateKey(rand.Reader)
183 if err != nil {
184 b.Fatalf("%v", err)
185 }
186 b.ReportAllocs()
187
188 for i := 0; i < b.N; i++ {
189 _, err := buf.Write(priv[:])
190 if err != nil {
191 b.Fatalf("%v", err)
192 }
193 _, err = buf.Write(pub[:])
194 if err != nil {
195 b.Fatalf("%v", err)
196 }
197 b.SetBytes(64)
198 }
199 }
200
201 func BenchmarkFixed(b *testing.B) {
202 pub, priv, err := box.GenerateKey(rand.Reader)
203 if err != nil {
204 b.Fatalf("%v", err)
205 }
206
207 buf = NewBuffer(64 * b.N)
208 b.ReportAllocs()
209
210 for i := 0; i < b.N; i++ {
211 _, err := buf.Write(priv[:])
212 if err != nil {
213 b.Fatalf("%v", err)
214 }
215 _, err = buf.Write(pub[:])
216 if err != nil {
217 b.Fatalf("%v", err)
218 }
219 b.SetBytes(64)
220 }
221 }
222
223 func BenchmarkWrite(b *testing.B) {
224 var pub = new([32]byte)
225 var priv = new([32]byte)
226
227 b.ReportAllocs()
228
229 for i := 0; i < b.N && buf.Len() >= 64; i++ {
230 _, err := buf.Read(priv[:])
231 if err != nil {
232 b.Fatalf("%v", err)
233 }
234 _, err = buf.Read(pub[:])
235 if err != nil {
236 b.Fatalf("%v", err)
237 }
238 b.SetBytes(64)
239 }
240 }