github.com/dominant-strategies/go-quai@v0.28.2/common/types_test.go (about)

     1  // Copyright 2015 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  	"database/sql/driver"
    22  	"encoding/json"
    23  	"fmt"
    24  	"math/big"
    25  	"reflect"
    26  	"strings"
    27  	"testing"
    28  )
    29  
    30  func TestBytesConversion(t *testing.T) {
    31  	bytes := []byte{5}
    32  	hash := BytesToHash(bytes)
    33  
    34  	var exp Hash
    35  	exp[31] = 5
    36  
    37  	if hash != exp {
    38  		t.Errorf("expected %x got %x", exp, hash)
    39  	}
    40  }
    41  
    42  func TestIsHexAddress(t *testing.T) {
    43  	tests := []struct {
    44  		str string
    45  		exp bool
    46  	}{
    47  		{"0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed", true},
    48  		{"5aaeb6053f3e94c9b9a09f33669435e7ef1beaed", true},
    49  		{"0X5aaeb6053f3e94c9b9a09f33669435e7ef1beaed", true},
    50  		{"0XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", true},
    51  		{"0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", true},
    52  		{"0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed1", false},
    53  		{"0x5aaeb6053f3e94c9b9a09f33669435e7ef1beae", false},
    54  		{"5aaeb6053f3e94c9b9a09f33669435e7ef1beaed11", false},
    55  		{"0xxaaeb6053f3e94c9b9a09f33669435e7ef1beaed", false},
    56  	}
    57  
    58  	for _, test := range tests {
    59  		if result := IsHexAddress(test.str); result != test.exp {
    60  			t.Errorf("IsHexAddress(%s) == %v; expected %v",
    61  				test.str, result, test.exp)
    62  		}
    63  	}
    64  }
    65  
    66  func TestHashJsonValidation(t *testing.T) {
    67  	var tests = []struct {
    68  		Prefix string
    69  		Size   int
    70  		Error  string
    71  	}{
    72  		{"", 62, "json: cannot unmarshal hex string without 0x prefix into Go value of type common.Hash"},
    73  		{"0x", 66, "hex string has length 66, want 64 for common.Hash"},
    74  		{"0x", 63, "json: cannot unmarshal hex string of odd length into Go value of type common.Hash"},
    75  		{"0x", 0, "hex string has length 0, want 64 for common.Hash"},
    76  		{"0x", 64, ""},
    77  		{"0X", 64, ""},
    78  	}
    79  	for _, test := range tests {
    80  		input := `"` + test.Prefix + strings.Repeat("0", test.Size) + `"`
    81  		var v Hash
    82  		err := json.Unmarshal([]byte(input), &v)
    83  		if err == nil {
    84  			if test.Error != "" {
    85  				t.Errorf("%s: error mismatch: have nil, want %q", input, test.Error)
    86  			}
    87  		} else {
    88  			if err.Error() != test.Error {
    89  				t.Errorf("%s: error mismatch: have %q, want %q", input, err, test.Error)
    90  			}
    91  		}
    92  	}
    93  }
    94  
    95  func TestAddressUnmarshalJSON(t *testing.T) {
    96  	var tests = []struct {
    97  		Input     string
    98  		ShouldErr bool
    99  		Output    *big.Int
   100  	}{
   101  		{"", true, nil},
   102  		{`""`, true, nil},
   103  		{`"0x"`, true, nil},
   104  		{`"0x00"`, true, nil},
   105  		{`"0xG000000000000000000000000000000000000000"`, true, nil},
   106  		{`"0x0000000000000000000000000000000000000000"`, false, big.NewInt(0)},
   107  		{`"0x0000000000000000000000000000000000000010"`, false, big.NewInt(16)},
   108  	}
   109  	for i, test := range tests {
   110  		var v Address
   111  		err := json.Unmarshal([]byte(test.Input), &v)
   112  		if err != nil && !test.ShouldErr {
   113  			t.Errorf("test #%d: unexpected error: %v", i, err)
   114  		}
   115  		if err == nil {
   116  			if test.ShouldErr {
   117  				t.Errorf("test #%d: expected error, got none", i)
   118  			}
   119  			if got := new(big.Int).SetBytes(v.Bytes()); got.Cmp(test.Output) != 0 {
   120  				t.Errorf("test #%d: address mismatch: have %v, want %v", i, got, test.Output)
   121  			}
   122  		}
   123  	}
   124  }
   125  
   126  func TestAddressHexChecksum(t *testing.T) {
   127  	var tests = []struct {
   128  		Input  string
   129  		Output string
   130  	}{
   131  		{"0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed", "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed"},
   132  		{"0xfb6916095ca1df60bb79ce92ce3ea74c37c5d359", "0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359"},
   133  		{"0xdbf03b407c01e7cd3cbea99509d93f8dddc8c6fb", "0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB"},
   134  		{"0xd1220a0cf47c7b9be7a2e6ba89f429762e7b9adb", "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb"},
   135  		// Ensure that non-standard length input values are handled correctly
   136  		{"0xa", "0x000000000000000000000000000000000000000A"},
   137  		{"0x0a", "0x000000000000000000000000000000000000000A"},
   138  		{"0x00a", "0x000000000000000000000000000000000000000A"},
   139  		{"0x000000000000000000000000000000000000000a", "0x000000000000000000000000000000000000000A"},
   140  	}
   141  	for i, test := range tests {
   142  		output := HexToAddress(test.Input).Hex()
   143  		if output != test.Output {
   144  			t.Errorf("test #%d: failed to match when it should (%s != %s)", i, output, test.Output)
   145  		}
   146  	}
   147  }
   148  
   149  func BenchmarkAddressHex(b *testing.B) {
   150  	testAddr := HexToAddress("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed")
   151  	for n := 0; n < b.N; n++ {
   152  		testAddr.Hex()
   153  	}
   154  }
   155  
   156  func TestMixedcaseAccount_Address(t *testing.T) {
   157  
   158  	// Note: 0X{checksum_addr} is not valid according to spec
   159  
   160  	var res []struct {
   161  		A     MixedcaseAddress
   162  		Valid bool
   163  	}
   164  	if err := json.Unmarshal([]byte(`[
   165  		{"A" : "0xae967917c465db8578ca9024c205720b1a3651A9", "Valid": false},
   166  		{"A" : "0xAe967917c465db8578ca9024c205720b1a3651A9", "Valid": true},
   167  		{"A" : "0XAe967917c465db8578ca9024c205720b1a3651A9", "Valid": false},
   168  		{"A" : "0x1111111111111111111112222222222223333323", "Valid": true}
   169  		]`), &res); err != nil {
   170  		t.Fatal(err)
   171  	}
   172  
   173  	for _, r := range res {
   174  		if got := r.A.ValidChecksum(); got != r.Valid {
   175  			t.Errorf("Expected checksum %v, got checksum %v, input %v", r.Valid, got, r.A.String())
   176  		}
   177  	}
   178  
   179  	//These should throw exceptions:
   180  	var r2 []MixedcaseAddress
   181  	for _, r := range []string{
   182  		`["0x11111111111111111111122222222222233333"]`,     // Too short
   183  		`["0x111111111111111111111222222222222333332"]`,    // Too short
   184  		`["0x11111111111111111111122222222222233333234"]`,  // Too long
   185  		`["0x111111111111111111111222222222222333332344"]`, // Too long
   186  		`["1111111111111111111112222222222223333323"]`,     // Missing 0x
   187  		`["x1111111111111111111112222222222223333323"]`,    // Missing 0
   188  		`["0xG111111111111111111112222222222223333323"]`,   //Non-hex
   189  	} {
   190  		if err := json.Unmarshal([]byte(r), &r2); err == nil {
   191  			t.Errorf("Expected failure, input %v", r)
   192  		}
   193  
   194  	}
   195  
   196  }
   197  
   198  func TestHash_Scan(t *testing.T) {
   199  	type args struct {
   200  		src interface{}
   201  	}
   202  	tests := []struct {
   203  		name    string
   204  		args    args
   205  		wantErr bool
   206  	}{
   207  		{
   208  			name: "working scan",
   209  			args: args{src: []byte{
   210  				0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, 0xf6, 0x3e,
   211  				0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   212  				0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   213  				0x10, 0x00,
   214  			}},
   215  			wantErr: false,
   216  		},
   217  		{
   218  			name:    "non working scan",
   219  			args:    args{src: int64(1234567890)},
   220  			wantErr: true,
   221  		},
   222  		{
   223  			name: "invalid length scan",
   224  			args: args{src: []byte{
   225  				0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, 0xf6, 0x3e,
   226  				0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   227  				0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   228  			}},
   229  			wantErr: true,
   230  		},
   231  	}
   232  	for _, tt := range tests {
   233  		t.Run(tt.name, func(t *testing.T) {
   234  			h := &Hash{}
   235  			if err := h.Scan(tt.args.src); (err != nil) != tt.wantErr {
   236  				t.Errorf("Hash.Scan() error = %v, wantErr %v", err, tt.wantErr)
   237  			}
   238  
   239  			if !tt.wantErr {
   240  				for i := range h {
   241  					if h[i] != tt.args.src.([]byte)[i] {
   242  						t.Errorf(
   243  							"Hash.Scan() didn't scan the %d src correctly (have %X, want %X)",
   244  							i, h[i], tt.args.src.([]byte)[i],
   245  						)
   246  					}
   247  				}
   248  			}
   249  		})
   250  	}
   251  }
   252  
   253  func TestHash_Value(t *testing.T) {
   254  	b := []byte{
   255  		0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, 0xf6, 0x3e,
   256  		0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   257  		0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   258  		0x10, 0x00,
   259  	}
   260  	var usedH Hash
   261  	usedH.SetBytes(b)
   262  	tests := []struct {
   263  		name    string
   264  		h       Hash
   265  		want    driver.Value
   266  		wantErr bool
   267  	}{
   268  		{
   269  			name:    "Working value",
   270  			h:       usedH,
   271  			want:    b,
   272  			wantErr: false,
   273  		},
   274  	}
   275  	for _, tt := range tests {
   276  		t.Run(tt.name, func(t *testing.T) {
   277  			got, err := tt.h.Value()
   278  			if (err != nil) != tt.wantErr {
   279  				t.Errorf("Hash.Value() error = %v, wantErr %v", err, tt.wantErr)
   280  				return
   281  			}
   282  			if !reflect.DeepEqual(got, tt.want) {
   283  				t.Errorf("Hash.Value() = %v, want %v", got, tt.want)
   284  			}
   285  		})
   286  	}
   287  }
   288  
   289  func TestAddress_Scan(t *testing.T) {
   290  	type args struct {
   291  		src interface{}
   292  	}
   293  	tests := []struct {
   294  		name    string
   295  		args    args
   296  		wantErr bool
   297  	}{
   298  		{
   299  			name: "working scan",
   300  			args: args{src: []byte{
   301  				0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, 0xf6, 0x3e,
   302  				0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   303  			}},
   304  			wantErr: false,
   305  		},
   306  		{
   307  			name:    "non working scan",
   308  			args:    args{src: int64(1234567890)},
   309  			wantErr: true,
   310  		},
   311  		{
   312  			name: "invalid length scan",
   313  			args: args{src: []byte{
   314  				0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, 0xf6, 0x3e,
   315  				0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a,
   316  			}},
   317  			wantErr: true,
   318  		},
   319  	}
   320  	for _, tt := range tests {
   321  		t.Run(tt.name, func(t *testing.T) {
   322  			a := &Address{}
   323  			if err := a.Scan(tt.args.src); (err != nil) != tt.wantErr {
   324  				t.Errorf("Address.Scan() error = %v, wantErr %v", err, tt.wantErr)
   325  			}
   326  
   327  			if !tt.wantErr {
   328  				for i := range a.Bytes() {
   329  					if a.Bytes()[i] != tt.args.src.([]byte)[i] {
   330  						t.Errorf(
   331  							"Address.Scan() didn't scan the %d src correctly (have %X, want %X)",
   332  							i, a.Bytes()[i], tt.args.src.([]byte)[i],
   333  						)
   334  					}
   335  				}
   336  			}
   337  		})
   338  	}
   339  }
   340  
   341  func TestAddress_Value(t *testing.T) {
   342  	b := []byte{
   343  		0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, 0xf6, 0x3e,
   344  		0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   345  	}
   346  	usedA := BytesToAddress(b);
   347  	tests := []struct {
   348  		name    string
   349  		a       Address
   350  		want    driver.Value
   351  		wantErr bool
   352  	}{
   353  		{
   354  			name:    "Working value",
   355  			a:       usedA,
   356  			want:    b,
   357  			wantErr: false,
   358  		},
   359  	}
   360  	for _, tt := range tests {
   361  		t.Run(tt.name, func(t *testing.T) {
   362  			got, err := tt.a.Value()
   363  			if (err != nil) != tt.wantErr {
   364  				t.Errorf("Address.Value() error = %v, wantErr %v", err, tt.wantErr)
   365  				return
   366  			}
   367  			if !reflect.DeepEqual(got, tt.want) {
   368  				t.Errorf("Address.Value() = %v, want %v", got, tt.want)
   369  			}
   370  		})
   371  	}
   372  }
   373  
   374  func TestAddress_Format(t *testing.T) {
   375  	b := []byte{
   376  		0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, 0xf6, 0x3e,
   377  		0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   378  	}
   379  
   380  	addr := BytesToAddress(b)
   381  	tests := []struct {
   382  		name string
   383  		out  string
   384  		want string
   385  	}{
   386  		{
   387  			name: "println",
   388  			out:  fmt.Sprintln(addr),
   389  			want: "0xB26f2b342AAb24BCF63ea218c6A9274D30Ab9A15\n",
   390  		},
   391  		{
   392  			name: "print",
   393  			out:  fmt.Sprint(addr),
   394  			want: "0xB26f2b342AAb24BCF63ea218c6A9274D30Ab9A15",
   395  		},
   396  		{
   397  			name: "printf-s",
   398  			out: func() string {
   399  				buf := new(bytes.Buffer)
   400  				fmt.Fprintf(buf, "%s", addr)
   401  				return buf.String()
   402  			}(),
   403  			want: "0xB26f2b342AAb24BCF63ea218c6A9274D30Ab9A15",
   404  		},
   405  		{
   406  			name: "printf-q",
   407  			out:  fmt.Sprintf("%q", addr),
   408  			want: `"0xB26f2b342AAb24BCF63ea218c6A9274D30Ab9A15"`,
   409  		},
   410  		{
   411  			name: "printf-x",
   412  			out:  fmt.Sprintf("%x", addr),
   413  			want: "b26f2b342aab24bcf63ea218c6a9274d30ab9a15",
   414  		},
   415  		{
   416  			name: "printf-X",
   417  			out:  fmt.Sprintf("%X", addr),
   418  			want: "B26F2B342AAB24BCF63EA218C6A9274D30AB9A15",
   419  		},
   420  		{
   421  			name: "printf-#x",
   422  			out:  fmt.Sprintf("%#x", addr),
   423  			want: "0xb26f2b342aab24bcf63ea218c6a9274d30ab9a15",
   424  		},
   425  		{
   426  			name: "printf-v",
   427  			out:  fmt.Sprintf("%v", addr),
   428  			want: "0xB26f2b342AAb24BCF63ea218c6A9274D30Ab9A15",
   429  		},
   430  		// The original default formatter for byte slice
   431  		{
   432  			name: "printf-d",
   433  			out:  fmt.Sprintf("%d", addr),
   434  			want: "[178 111 43 52 42 171 36 188 246 62 162 24 198 169 39 77 48 171 154 21]",
   435  		},
   436  		// Invalid format char.
   437  		{
   438  			name: "printf-t",
   439  			out:  fmt.Sprintf("%t", addr),
   440  			want: "%!t(address=b26f2b342aab24bcf63ea218c6a9274d30ab9a15)",
   441  		},
   442  	}
   443  	for _, tt := range tests {
   444  		t.Run(tt.name, func(t *testing.T) {
   445  			if tt.out != tt.want {
   446  				t.Errorf("%s does not render as expected:\n got %s\nwant %s", tt.name, tt.out, tt.want)
   447  			}
   448  		})
   449  	}
   450  }
   451  
   452  func TestHash_Format(t *testing.T) {
   453  	var hash Hash
   454  	hash.SetBytes([]byte{
   455  		0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, 0xf6, 0x3e,
   456  		0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   457  		0xa2, 0x18, 0xc6, 0xa9, 0x27, 0x4d, 0x30, 0xab, 0x9a, 0x15,
   458  		0x10, 0x00,
   459  	})
   460  
   461  	tests := []struct {
   462  		name string
   463  		out  string
   464  		want string
   465  	}{
   466  		{
   467  			name: "println",
   468  			out:  fmt.Sprintln(hash),
   469  			want: "0xb26f2b342aab24bcf63ea218c6a9274d30ab9a15a218c6a9274d30ab9a151000\n",
   470  		},
   471  		{
   472  			name: "print",
   473  			out:  fmt.Sprint(hash),
   474  			want: "0xb26f2b342aab24bcf63ea218c6a9274d30ab9a15a218c6a9274d30ab9a151000",
   475  		},
   476  		{
   477  			name: "printf-s",
   478  			out: func() string {
   479  				buf := new(bytes.Buffer)
   480  				fmt.Fprintf(buf, "%s", hash)
   481  				return buf.String()
   482  			}(),
   483  			want: "0xb26f2b342aab24bcf63ea218c6a9274d30ab9a15a218c6a9274d30ab9a151000",
   484  		},
   485  		{
   486  			name: "printf-q",
   487  			out:  fmt.Sprintf("%q", hash),
   488  			want: `"0xb26f2b342aab24bcf63ea218c6a9274d30ab9a15a218c6a9274d30ab9a151000"`,
   489  		},
   490  		{
   491  			name: "printf-x",
   492  			out:  fmt.Sprintf("%x", hash),
   493  			want: "b26f2b342aab24bcf63ea218c6a9274d30ab9a15a218c6a9274d30ab9a151000",
   494  		},
   495  		{
   496  			name: "printf-X",
   497  			out:  fmt.Sprintf("%X", hash),
   498  			want: "B26F2B342AAB24BCF63EA218C6A9274D30AB9A15A218C6A9274D30AB9A151000",
   499  		},
   500  		{
   501  			name: "printf-#x",
   502  			out:  fmt.Sprintf("%#x", hash),
   503  			want: "0xb26f2b342aab24bcf63ea218c6a9274d30ab9a15a218c6a9274d30ab9a151000",
   504  		},
   505  		{
   506  			name: "printf-#X",
   507  			out:  fmt.Sprintf("%#X", hash),
   508  			want: "0XB26F2B342AAB24BCF63EA218C6A9274D30AB9A15A218C6A9274D30AB9A151000",
   509  		},
   510  		{
   511  			name: "printf-v",
   512  			out:  fmt.Sprintf("%v", hash),
   513  			want: "0xb26f2b342aab24bcf63ea218c6a9274d30ab9a15a218c6a9274d30ab9a151000",
   514  		},
   515  		// The original default formatter for byte slice
   516  		{
   517  			name: "printf-d",
   518  			out:  fmt.Sprintf("%d", hash),
   519  			want: "[178 111 43 52 42 171 36 188 246 62 162 24 198 169 39 77 48 171 154 21 162 24 198 169 39 77 48 171 154 21 16 0]",
   520  		},
   521  		// Invalid format char.
   522  		{
   523  			name: "printf-t",
   524  			out:  fmt.Sprintf("%t", hash),
   525  			want: "%!t(hash=b26f2b342aab24bcf63ea218c6a9274d30ab9a15a218c6a9274d30ab9a151000)",
   526  		},
   527  	}
   528  	for _, tt := range tests {
   529  		t.Run(tt.name, func(t *testing.T) {
   530  			if tt.out != tt.want {
   531  				t.Errorf("%s does not render as expected:\n got %s\nwant %s", tt.name, tt.out, tt.want)
   532  			}
   533  		})
   534  	}
   535  }