github.com/MikyChow/arbitrum-go-ethereum@v0.0.0-20230306102812-078da49636de/common/bytes_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 common
    18  
    19  import (
    20  	"bytes"
    21  	"testing"
    22  )
    23  
    24  func TestCopyBytes(t *testing.T) {
    25  	input := []byte{1, 2, 3, 4}
    26  
    27  	v := CopyBytes(input)
    28  	if !bytes.Equal(v, []byte{1, 2, 3, 4}) {
    29  		t.Fatal("not equal after copy")
    30  	}
    31  	v[0] = 99
    32  	if bytes.Equal(v, input) {
    33  		t.Fatal("result is not a copy")
    34  	}
    35  }
    36  
    37  func TestLeftPadBytes(t *testing.T) {
    38  	val := []byte{1, 2, 3, 4}
    39  	padded := []byte{0, 0, 0, 0, 1, 2, 3, 4}
    40  
    41  	if r := LeftPadBytes(val, 8); !bytes.Equal(r, padded) {
    42  		t.Fatalf("LeftPadBytes(%v, 8) == %v", val, r)
    43  	}
    44  	if r := LeftPadBytes(val, 2); !bytes.Equal(r, val) {
    45  		t.Fatalf("LeftPadBytes(%v, 2) == %v", val, r)
    46  	}
    47  }
    48  
    49  func TestRightPadBytes(t *testing.T) {
    50  	val := []byte{1, 2, 3, 4}
    51  	padded := []byte{1, 2, 3, 4, 0, 0, 0, 0}
    52  
    53  	if r := RightPadBytes(val, 8); !bytes.Equal(r, padded) {
    54  		t.Fatalf("RightPadBytes(%v, 8) == %v", val, r)
    55  	}
    56  	if r := RightPadBytes(val, 2); !bytes.Equal(r, val) {
    57  		t.Fatalf("RightPadBytes(%v, 2) == %v", val, r)
    58  	}
    59  }
    60  
    61  func TestFromHex(t *testing.T) {
    62  	input := "0x01"
    63  	expected := []byte{1}
    64  	result := FromHex(input)
    65  	if !bytes.Equal(expected, result) {
    66  		t.Errorf("Expected %x got %x", expected, result)
    67  	}
    68  }
    69  
    70  func TestIsHex(t *testing.T) {
    71  	tests := []struct {
    72  		input string
    73  		ok    bool
    74  	}{
    75  		{"", true},
    76  		{"0", false},
    77  		{"00", true},
    78  		{"a9e67e", true},
    79  		{"A9E67E", true},
    80  		{"0xa9e67e", false},
    81  		{"a9e67e001", false},
    82  		{"0xHELLO_MY_NAME_IS_STEVEN_@#$^&*", false},
    83  	}
    84  	for _, test := range tests {
    85  		if ok := isHex(test.input); ok != test.ok {
    86  			t.Errorf("isHex(%q) = %v, want %v", test.input, ok, test.ok)
    87  		}
    88  	}
    89  }
    90  
    91  func TestFromHexOddLength(t *testing.T) {
    92  	input := "0x1"
    93  	expected := []byte{1}
    94  	result := FromHex(input)
    95  	if !bytes.Equal(expected, result) {
    96  		t.Errorf("Expected %x got %x", expected, result)
    97  	}
    98  }
    99  
   100  func TestNoPrefixShortHexOddLength(t *testing.T) {
   101  	input := "1"
   102  	expected := []byte{1}
   103  	result := FromHex(input)
   104  	if !bytes.Equal(expected, result) {
   105  		t.Errorf("Expected %x got %x", expected, result)
   106  	}
   107  }
   108  
   109  func TestTrimRightZeroes(t *testing.T) {
   110  	tests := []struct {
   111  		arr []byte
   112  		exp []byte
   113  	}{
   114  		{FromHex("0x00ffff00ff0000"), FromHex("0x00ffff00ff")},
   115  		{FromHex("0x00000000000000"), []byte{}},
   116  		{FromHex("0xff"), FromHex("0xff")},
   117  		{[]byte{}, []byte{}},
   118  		{FromHex("0x00ffffffffffff"), FromHex("0x00ffffffffffff")},
   119  	}
   120  	for i, test := range tests {
   121  		got := TrimRightZeroes(test.arr)
   122  		if !bytes.Equal(got, test.exp) {
   123  			t.Errorf("test %d, got %x exp %x", i, got, test.exp)
   124  		}
   125  	}
   126  }