src/encoding/hex/hex_test.go

   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
   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         // 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
  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)} // 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
 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                 // 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
 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 }