github.com/varialus/godfly@v0.0.0-20130904042352-1934f9f095ab/src/pkg/encoding/hex/hex_test.go (about)

     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  	"testing"
    10  )
    11  
    12  type encDecTest struct {
    13  	enc string
    14  	dec []byte
    15  }
    16  
    17  var encDecTests = []encDecTest{
    18  	{"", []byte{}},
    19  	{"0001020304050607", []byte{0, 1, 2, 3, 4, 5, 6, 7}},
    20  	{"08090a0b0c0d0e0f", []byte{8, 9, 10, 11, 12, 13, 14, 15}},
    21  	{"f0f1f2f3f4f5f6f7", []byte{0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7}},
    22  	{"f8f9fafbfcfdfeff", []byte{0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff}},
    23  	{"67", []byte{'g'}},
    24  	{"e3a1", []byte{0xe3, 0xa1}},
    25  }
    26  
    27  func TestEncode(t *testing.T) {
    28  	for i, test := range encDecTests {
    29  		dst := make([]byte, EncodedLen(len(test.dec)))
    30  		n := Encode(dst, test.dec)
    31  		if n != len(dst) {
    32  			t.Errorf("#%d: bad return value: got: %d want: %d", i, n, len(dst))
    33  		}
    34  		if string(dst) != test.enc {
    35  			t.Errorf("#%d: got: %#v want: %#v", i, dst, test.enc)
    36  		}
    37  	}
    38  }
    39  
    40  func TestDecode(t *testing.T) {
    41  	for i, test := range encDecTests {
    42  		dst := make([]byte, DecodedLen(len(test.enc)))
    43  		n, err := Decode(dst, []byte(test.enc))
    44  		if err != nil {
    45  			t.Errorf("#%d: bad return value: got:%d want:%d", i, n, len(dst))
    46  		} else if !bytes.Equal(dst, test.dec) {
    47  			t.Errorf("#%d: got: %#v want: %#v", i, dst, test.dec)
    48  		}
    49  	}
    50  }
    51  
    52  func TestEncodeToString(t *testing.T) {
    53  	for i, test := range encDecTests {
    54  		s := EncodeToString(test.dec)
    55  		if s != test.enc {
    56  			t.Errorf("#%d got:%s want:%s", i, s, test.enc)
    57  		}
    58  	}
    59  }
    60  
    61  func TestDecodeString(t *testing.T) {
    62  	for i, test := range encDecTests {
    63  		dst, err := DecodeString(test.enc)
    64  		if err != nil {
    65  			t.Errorf("#%d: unexpected err value: %s", i, err)
    66  			continue
    67  		}
    68  		if !bytes.Equal(dst, test.dec) {
    69  			t.Errorf("#%d: got: %#v want: #%v", i, dst, test.dec)
    70  		}
    71  	}
    72  }
    73  
    74  type errTest struct {
    75  	in  string
    76  	err string
    77  }
    78  
    79  var errTests = []errTest{
    80  	{"0", "encoding/hex: odd length hex string"},
    81  	{"0g", "encoding/hex: invalid byte: U+0067 'g'"},
    82  	{"0\x01", "encoding/hex: invalid byte: U+0001"},
    83  }
    84  
    85  func TestInvalidErr(t *testing.T) {
    86  	for i, test := range errTests {
    87  		dst := make([]byte, DecodedLen(len(test.in)))
    88  		_, err := Decode(dst, []byte(test.in))
    89  		if err == nil {
    90  			t.Errorf("#%d: expected error; got none", i)
    91  		} else if err.Error() != test.err {
    92  			t.Errorf("#%d: got: %v want: %v", i, err, test.err)
    93  		}
    94  	}
    95  }
    96  
    97  func TestInvalidStringErr(t *testing.T) {
    98  	for i, test := range errTests {
    99  		_, err := DecodeString(test.in)
   100  		if err == nil {
   101  			t.Errorf("#%d: expected error; got none", i)
   102  		} else if err.Error() != test.err {
   103  			t.Errorf("#%d: got: %v want: %v", i, err, test.err)
   104  		}
   105  	}
   106  }
   107  
   108  func TestDumper(t *testing.T) {
   109  	var in [40]byte
   110  	for i := range in {
   111  		in[i] = byte(i + 30)
   112  	}
   113  
   114  	for stride := 1; stride < len(in); stride++ {
   115  		var out bytes.Buffer
   116  		dumper := Dumper(&out)
   117  		done := 0
   118  		for done < len(in) {
   119  			todo := done + stride
   120  			if todo > len(in) {
   121  				todo = len(in)
   122  			}
   123  			dumper.Write(in[done:todo])
   124  			done = todo
   125  		}
   126  
   127  		dumper.Close()
   128  		if !bytes.Equal(out.Bytes(), expectedHexDump) {
   129  			t.Errorf("stride: %d failed. got:\n%s\nwant:\n%s", stride, out.Bytes(), expectedHexDump)
   130  		}
   131  	}
   132  }
   133  
   134  func TestDump(t *testing.T) {
   135  	var in [40]byte
   136  	for i := range in {
   137  		in[i] = byte(i + 30)
   138  	}
   139  
   140  	out := []byte(Dump(in[:]))
   141  	if !bytes.Equal(out, expectedHexDump) {
   142  		t.Errorf("got:\n%s\nwant:\n%s", out, expectedHexDump)
   143  	}
   144  }
   145  
   146  var expectedHexDump = []byte(`00000000  1e 1f 20 21 22 23 24 25  26 27 28 29 2a 2b 2c 2d  |.. !"#$%&'()*+,-|
   147  00000010  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
   148  00000020  3e 3f 40 41 42 43 44 45                           |>?@ABCDE|
   149  `)