1// Copyright 2009 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package hex
6
7import (
8	"bytes"
9	"fmt"
10	"io"
11	"strings"
12	"testing"
13)
14
15type encDecTest struct {
16	enc string
17	dec []byte
18}
19
20var 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
30func 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
48func TestDecode(t *testing.T) {
49	// Case for decoding uppercase hex characters, since
50	// Encode always uses lowercase.
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
70func 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
79func 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
92var 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
108func 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
118func 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
127func 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)} // io.Reader only; not io.WriterTo
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} // io.Writer only; not io.ReaderFrom
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
161func 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		// Decoder is reading from stream, so it reports io.ErrUnexpectedEOF instead of ErrLength.
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
176func 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
202func 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
218func 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
231func 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
243var expectedHexDump = []byte(`00000000  1e 1f 20 21 22 23 24 25  26 27 28 29 2a 2b 2c 2d  |.. !"#$%&'()*+,-|
24400000010  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
24500000020  3e 3f 40 41 42 43 44 45                           |>?@ABCDE|
246`)
247
248var sink []byte
249
250func 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
264func 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
278func BenchmarkDecodeString(b *testing.B) {
279	for _, size := range []int{256, 1024, 4096, 16384} {
280		src := strings.Repeat("2b744faa", size/8)
281		b.Run(fmt.Sprintf("%v", size), func(b *testing.B) {
282			b.SetBytes(int64(size))
283			for i := 0; i < b.N; i++ {
284				sink, _ = DecodeString(src)
285			}
286		})
287	}
288}
289
290func BenchmarkDump(b *testing.B) {
291	for _, size := range []int{256, 1024, 4096, 16384} {
292		src := bytes.Repeat([]byte{2, 3, 5, 7, 9, 11, 13, 17}, size/8)
293
294		b.Run(fmt.Sprintf("%v", size), func(b *testing.B) {
295			b.SetBytes(int64(size))
296			for i := 0; i < b.N; i++ {
297				Dump(src)
298			}
299		})
300	}
301}
302