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