1
2
3
4
5 package hex
6
7 import (
8 "bytes"
9 "fmt"
10 "io"
11 "strings"
12 "testing"
13 )
14
15 type encDecTest struct {
16 enc string
17 dec []byte
18 }
19
20 var encDecTests = []encDecTest{
21 {"", []byte{}},
22 {"0001020304050607", []byte{0, 1, 2, 3, 4, 5, 6, 7}},
23 {"08090a0b0c0d0e0f", []byte{8, 9, 10, 11, 12, 13, 14, 15}},
24 {"f0f1f2f3f4f5f6f7", []byte{0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7}},
25 {"f8f9fafbfcfdfeff", []byte{0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff}},
26 {"67", []byte{'g'}},
27 {"e3a1", []byte{0xe3, 0xa1}},
28 }
29
30 func TestEncode(t *testing.T) {
31 for i, test := range encDecTests {
32 dst := make([]byte, EncodedLen(len(test.dec)))
33 n := Encode(dst, test.dec)
34 if n != len(dst) {
35 t.Errorf("#%d: bad return value: got: %d want: %d", i, n, len(dst))
36 }
37 if string(dst) != test.enc {
38 t.Errorf("#%d: got: %#v want: %#v", i, dst, test.enc)
39 }
40 dst = []byte("lead")
41 dst = AppendEncode(dst, test.dec)
42 if string(dst) != "lead"+test.enc {
43 t.Errorf("#%d: got: %#v want: %#v", i, dst, "lead"+test.enc)
44 }
45 }
46 }
47
48 func TestDecode(t *testing.T) {
49
50
51 decTests := append(encDecTests, encDecTest{"F8F9FAFBFCFDFEFF", []byte{0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff}})
52 for i, test := range decTests {
53 dst := make([]byte, DecodedLen(len(test.enc)))
54 n, err := Decode(dst, []byte(test.enc))
55 if err != nil {
56 t.Errorf("#%d: bad return value: got:%d want:%d", i, n, len(dst))
57 } else if !bytes.Equal(dst, test.dec) {
58 t.Errorf("#%d: got: %#v want: %#v", i, dst, test.dec)
59 }
60 dst = []byte("lead")
61 dst, err = AppendDecode(dst, []byte(test.enc))
62 if err != nil {
63 t.Errorf("#%d: AppendDecode error: %v", i, err)
64 } else if string(dst) != "lead"+string(test.dec) {
65 t.Errorf("#%d: got: %#v want: %#v", i, dst, "lead"+string(test.dec))
66 }
67 }
68 }
69
70 func TestEncodeToString(t *testing.T) {
71 for i, test := range encDecTests {
72 s := EncodeToString(test.dec)
73 if s != test.enc {
74 t.Errorf("#%d got:%s want:%s", i, s, test.enc)
75 }
76 }
77 }
78
79 func TestDecodeString(t *testing.T) {
80 for i, test := range encDecTests {
81 dst, err := DecodeString(test.enc)
82 if err != nil {
83 t.Errorf("#%d: unexpected err value: %s", i, err)
84 continue
85 }
86 if !bytes.Equal(dst, test.dec) {
87 t.Errorf("#%d: got: %#v want: #%v", i, dst, test.dec)
88 }
89 }
90 }
91
92 var errTests = []struct {
93 in string
94 out string
95 err error
96 }{
97 {"", "", nil},
98 {"0", "", ErrLength},
99 {"zd4aa", "", InvalidByteError('z')},
100 {"d4aaz", "\xd4\xaa", InvalidByteError('z')},
101 {"30313", "01", ErrLength},
102 {"0g", "", InvalidByteError('g')},
103 {"00gg", "\x00", InvalidByteError('g')},
104 {"0\x01", "", InvalidByteError('\x01')},
105 {"ffeed", "\xff\xee", ErrLength},
106 }
107
108 func TestDecodeErr(t *testing.T) {
109 for _, tt := range errTests {
110 out := make([]byte, len(tt.in)+10)
111 n, err := Decode(out, []byte(tt.in))
112 if string(out[:n]) != tt.out || err != tt.err {
113 t.Errorf("Decode(%q) = %q, %v, want %q, %v", tt.in, string(out[:n]), err, tt.out, tt.err)
114 }
115 }
116 }
117
118 func TestDecodeStringErr(t *testing.T) {
119 for _, tt := range errTests {
120 out, err := DecodeString(tt.in)
121 if string(out) != tt.out || err != tt.err {
122 t.Errorf("DecodeString(%q) = %q, %v, want %q, %v", tt.in, out, err, tt.out, tt.err)
123 }
124 }
125 }
126
127 func TestEncoderDecoder(t *testing.T) {
128 for _, multiplier := range []int{1, 128, 192} {
129 for _, test := range encDecTests {
130 input := bytes.Repeat(test.dec, multiplier)
131 output := strings.Repeat(test.enc, multiplier)
132
133 var buf bytes.Buffer
134 enc := NewEncoder(&buf)
135 r := struct{ io.Reader }{bytes.NewReader(input)}
136 if n, err := io.CopyBuffer(enc, r, make([]byte, 7)); n != int64(len(input)) || err != nil {
137 t.Errorf("encoder.Write(%q*%d) = (%d, %v), want (%d, nil)", test.dec, multiplier, n, err, len(input))
138 continue
139 }
140
141 if encDst := buf.String(); encDst != output {
142 t.Errorf("buf(%q*%d) = %v, want %v", test.dec, multiplier, encDst, output)
143 continue
144 }
145
146 dec := NewDecoder(&buf)
147 var decBuf bytes.Buffer
148 w := struct{ io.Writer }{&decBuf}
149 if _, err := io.CopyBuffer(w, dec, make([]byte, 7)); err != nil || decBuf.Len() != len(input) {
150 t.Errorf("decoder.Read(%q*%d) = (%d, %v), want (%d, nil)", test.enc, multiplier, decBuf.Len(), err, len(input))
151 }
152
153 if !bytes.Equal(decBuf.Bytes(), input) {
154 t.Errorf("decBuf(%q*%d) = %v, want %v", test.dec, multiplier, decBuf.Bytes(), input)
155 continue
156 }
157 }
158 }
159 }
160
161 func TestDecoderErr(t *testing.T) {
162 for _, tt := range errTests {
163 dec := NewDecoder(strings.NewReader(tt.in))
164 out, err := io.ReadAll(dec)
165 wantErr := tt.err
166
167 if wantErr == ErrLength {
168 wantErr = io.ErrUnexpectedEOF
169 }
170 if string(out) != tt.out || err != wantErr {
171 t.Errorf("NewDecoder(%q) = %q, %v, want %q, %v", tt.in, out, err, tt.out, wantErr)
172 }
173 }
174 }
175
176 func TestDumper(t *testing.T) {
177 var in [40]byte
178 for i := range in {
179 in[i] = byte(i + 30)
180 }
181
182 for stride := 1; stride < len(in); stride++ {
183 var out bytes.Buffer
184 dumper := Dumper(&out)
185 done := 0
186 for done < len(in) {
187 todo := done + stride
188 if todo > len(in) {
189 todo = len(in)
190 }
191 dumper.Write(in[done:todo])
192 done = todo
193 }
194
195 dumper.Close()
196 if !bytes.Equal(out.Bytes(), expectedHexDump) {
197 t.Errorf("stride: %d failed. got:\n%s\nwant:\n%s", stride, out.Bytes(), expectedHexDump)
198 }
199 }
200 }
201
202 func TestDumper_doubleclose(t *testing.T) {
203 var out strings.Builder
204 dumper := Dumper(&out)
205
206 dumper.Write([]byte(`gopher`))
207 dumper.Close()
208 dumper.Close()
209 dumper.Write([]byte(`gopher`))
210 dumper.Close()
211
212 expected := "00000000 67 6f 70 68 65 72 |gopher|\n"
213 if out.String() != expected {
214 t.Fatalf("got:\n%#v\nwant:\n%#v", out.String(), expected)
215 }
216 }
217
218 func TestDumper_earlyclose(t *testing.T) {
219 var out strings.Builder
220 dumper := Dumper(&out)
221
222 dumper.Close()
223 dumper.Write([]byte(`gopher`))
224
225 expected := ""
226 if out.String() != expected {
227 t.Fatalf("got:\n%#v\nwant:\n%#v", out.String(), expected)
228 }
229 }
230
231 func TestDump(t *testing.T) {
232 var in [40]byte
233 for i := range in {
234 in[i] = byte(i + 30)
235 }
236
237 out := []byte(Dump(in[:]))
238 if !bytes.Equal(out, expectedHexDump) {
239 t.Errorf("got:\n%s\nwant:\n%s", out, expectedHexDump)
240 }
241 }
242
243 var expectedHexDump = []byte(`00000000 1e 1f 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d |.. !"#$%&'()*+,-|
244 00000010 2e 2f 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d |./0123456789:;<=|
245 00000020 3e 3f 40 41 42 43 44 45 |>?@ABCDE|
246 `)
247
248 var sink []byte
249
250 func BenchmarkEncode(b *testing.B) {
251 for _, size := range []int{256, 1024, 4096, 16384} {
252 src := bytes.Repeat([]byte{2, 3, 5, 7, 9, 11, 13, 17}, size/8)
253 sink = make([]byte, 2*size)
254
255 b.Run(fmt.Sprintf("%v", size), func(b *testing.B) {
256 b.SetBytes(int64(size))
257 for i := 0; i < b.N; i++ {
258 Encode(sink, src)
259 }
260 })
261 }
262 }
263
264 func BenchmarkDecode(b *testing.B) {
265 for _, size := range []int{256, 1024, 4096, 16384} {
266 src := bytes.Repeat([]byte{'2', 'b', '7', '4', '4', 'f', 'a', 'a'}, size/8)
267 sink = make([]byte, size/2)
268
269 b.Run(fmt.Sprintf("%v", size), func(b *testing.B) {
270 b.SetBytes(int64(size))
271 for i := 0; i < b.N; i++ {
272 Decode(sink, src)
273 }
274 })
275 }
276 }
277
278 func BenchmarkDump(b *testing.B) {
279 for _, size := range []int{256, 1024, 4096, 16384} {
280 src := bytes.Repeat([]byte{2, 3, 5, 7, 9, 11, 13, 17}, size/8)
281
282 b.Run(fmt.Sprintf("%v", size), func(b *testing.B) {
283 b.SetBytes(int64(size))
284 for i := 0; i < b.N; i++ {
285 Dump(src)
286 }
287 })
288 }
289 }
290
View as plain text