github.com/MMMY001/go-ethereum@v1.9.7/trie/encoding_test.go (about)

     1  // Copyright 2014 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package trie
    18  
    19  import (
    20  	"bytes"
    21  	"testing"
    22  )
    23  
    24  func TestHexCompact(t *testing.T) {
    25  	tests := []struct{ hex, compact []byte }{
    26  		// empty keys, with and without terminator.
    27  		{hex: []byte{}, compact: []byte{0x00}},
    28  		{hex: []byte{16}, compact: []byte{0x20}},
    29  		// odd length, no terminator
    30  		{hex: []byte{1, 2, 3, 4, 5}, compact: []byte{0x11, 0x23, 0x45}},
    31  		// even length, no terminator
    32  		{hex: []byte{0, 1, 2, 3, 4, 5}, compact: []byte{0x00, 0x01, 0x23, 0x45}},
    33  		// odd length, terminator
    34  		{hex: []byte{15, 1, 12, 11, 8, 16 /*term*/}, compact: []byte{0x3f, 0x1c, 0xb8}},
    35  		// even length, terminator
    36  		{hex: []byte{0, 15, 1, 12, 11, 8, 16 /*term*/}, compact: []byte{0x20, 0x0f, 0x1c, 0xb8}},
    37  	}
    38  	for _, test := range tests {
    39  		if c := hexToCompact(test.hex); !bytes.Equal(c, test.compact) {
    40  			t.Errorf("hexToCompact(%x) -> %x, want %x", test.hex, c, test.compact)
    41  		}
    42  		if h := compactToHex(test.compact); !bytes.Equal(h, test.hex) {
    43  			t.Errorf("compactToHex(%x) -> %x, want %x", test.compact, h, test.hex)
    44  		}
    45  	}
    46  }
    47  
    48  func TestHexKeybytes(t *testing.T) {
    49  	tests := []struct{ key, hexIn, hexOut []byte }{
    50  		{key: []byte{}, hexIn: []byte{16}, hexOut: []byte{16}},
    51  		{key: []byte{}, hexIn: []byte{}, hexOut: []byte{16}},
    52  		{
    53  			key:    []byte{0x12, 0x34, 0x56},
    54  			hexIn:  []byte{1, 2, 3, 4, 5, 6, 16},
    55  			hexOut: []byte{1, 2, 3, 4, 5, 6, 16},
    56  		},
    57  		{
    58  			key:    []byte{0x12, 0x34, 0x5},
    59  			hexIn:  []byte{1, 2, 3, 4, 0, 5, 16},
    60  			hexOut: []byte{1, 2, 3, 4, 0, 5, 16},
    61  		},
    62  		{
    63  			key:    []byte{0x12, 0x34, 0x56},
    64  			hexIn:  []byte{1, 2, 3, 4, 5, 6},
    65  			hexOut: []byte{1, 2, 3, 4, 5, 6, 16},
    66  		},
    67  	}
    68  	for _, test := range tests {
    69  		if h := keybytesToHex(test.key); !bytes.Equal(h, test.hexOut) {
    70  			t.Errorf("keybytesToHex(%x) -> %x, want %x", test.key, h, test.hexOut)
    71  		}
    72  		if k := hexToKeybytes(test.hexIn); !bytes.Equal(k, test.key) {
    73  			t.Errorf("hexToKeybytes(%x) -> %x, want %x", test.hexIn, k, test.key)
    74  		}
    75  	}
    76  }
    77  
    78  func BenchmarkHexToCompact(b *testing.B) {
    79  	testBytes := []byte{0, 15, 1, 12, 11, 8, 16 /*term*/}
    80  	for i := 0; i < b.N; i++ {
    81  		hexToCompact(testBytes)
    82  	}
    83  }
    84  
    85  func BenchmarkCompactToHex(b *testing.B) {
    86  	testBytes := []byte{0, 15, 1, 12, 11, 8, 16 /*term*/}
    87  	for i := 0; i < b.N; i++ {
    88  		compactToHex(testBytes)
    89  	}
    90  }
    91  
    92  func BenchmarkKeybytesToHex(b *testing.B) {
    93  	testBytes := []byte{7, 6, 6, 5, 7, 2, 6, 2, 16}
    94  	for i := 0; i < b.N; i++ {
    95  		keybytesToHex(testBytes)
    96  	}
    97  }
    98  
    99  func BenchmarkHexToKeybytes(b *testing.B) {
   100  	testBytes := []byte{7, 6, 6, 5, 7, 2, 6, 2, 16}
   101  	for i := 0; i < b.N; i++ {
   102  		hexToKeybytes(testBytes)
   103  	}
   104  }