github.com/ethereum/go-ethereum@v1.16.1/internal/ethapi/simulate_test.go (about)

     1  // Copyright 2024 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 ethapi
    18  
    19  import (
    20  	"math/big"
    21  	"testing"
    22  
    23  	"github.com/ethereum/go-ethereum/common/hexutil"
    24  	"github.com/ethereum/go-ethereum/core/types"
    25  	"github.com/ethereum/go-ethereum/internal/ethapi/override"
    26  )
    27  
    28  func TestSimulateSanitizeBlockOrder(t *testing.T) {
    29  	type result struct {
    30  		number    uint64
    31  		timestamp uint64
    32  	}
    33  	for i, tc := range []struct {
    34  		baseNumber    int
    35  		baseTimestamp uint64
    36  		blocks        []simBlock
    37  		expected      []result
    38  		err           string
    39  	}{
    40  		{
    41  			baseNumber:    10,
    42  			baseTimestamp: 50,
    43  			blocks:        []simBlock{{}, {}, {}},
    44  			expected:      []result{{number: 11, timestamp: 62}, {number: 12, timestamp: 74}, {number: 13, timestamp: 86}},
    45  		},
    46  		{
    47  			baseNumber:    10,
    48  			baseTimestamp: 50,
    49  			blocks:        []simBlock{{BlockOverrides: &override.BlockOverrides{Number: newInt(13), Time: newUint64(80)}}, {}},
    50  			expected:      []result{{number: 11, timestamp: 62}, {number: 12, timestamp: 74}, {number: 13, timestamp: 80}, {number: 14, timestamp: 92}},
    51  		},
    52  		{
    53  			baseNumber:    10,
    54  			baseTimestamp: 50,
    55  			blocks:        []simBlock{{BlockOverrides: &override.BlockOverrides{Number: newInt(11)}}, {BlockOverrides: &override.BlockOverrides{Number: newInt(14)}}, {}},
    56  			expected:      []result{{number: 11, timestamp: 62}, {number: 12, timestamp: 74}, {number: 13, timestamp: 86}, {number: 14, timestamp: 98}, {number: 15, timestamp: 110}},
    57  		},
    58  		{
    59  			baseNumber:    10,
    60  			baseTimestamp: 50,
    61  			blocks:        []simBlock{{BlockOverrides: &override.BlockOverrides{Number: newInt(13)}}, {BlockOverrides: &override.BlockOverrides{Number: newInt(12)}}},
    62  			err:           "block numbers must be in order: 12 <= 13",
    63  		},
    64  		{
    65  			baseNumber:    10,
    66  			baseTimestamp: 50,
    67  			blocks:        []simBlock{{BlockOverrides: &override.BlockOverrides{Number: newInt(13), Time: newUint64(74)}}},
    68  			err:           "block timestamps must be in order: 74 <= 74",
    69  		},
    70  		{
    71  			baseNumber:    10,
    72  			baseTimestamp: 50,
    73  			blocks:        []simBlock{{BlockOverrides: &override.BlockOverrides{Number: newInt(11), Time: newUint64(60)}}, {BlockOverrides: &override.BlockOverrides{Number: newInt(12), Time: newUint64(55)}}},
    74  			err:           "block timestamps must be in order: 55 <= 60",
    75  		},
    76  		{
    77  			baseNumber:    10,
    78  			baseTimestamp: 50,
    79  			blocks:        []simBlock{{BlockOverrides: &override.BlockOverrides{Number: newInt(11), Time: newUint64(60)}}, {BlockOverrides: &override.BlockOverrides{Number: newInt(13), Time: newUint64(72)}}},
    80  			err:           "block timestamps must be in order: 72 <= 72",
    81  		},
    82  	} {
    83  		sim := &simulator{base: &types.Header{Number: big.NewInt(int64(tc.baseNumber)), Time: tc.baseTimestamp}}
    84  		res, err := sim.sanitizeChain(tc.blocks)
    85  		if err != nil {
    86  			if err.Error() == tc.err {
    87  				continue
    88  			} else {
    89  				t.Fatalf("testcase %d: error mismatch. Want '%s', have '%s'", i, tc.err, err.Error())
    90  			}
    91  		}
    92  		if err == nil && tc.err != "" {
    93  			t.Fatalf("testcase %d: expected err", i)
    94  		}
    95  		if len(res) != len(tc.expected) {
    96  			t.Errorf("testcase %d: mismatch number of blocks. Want %d, have %d", i, len(tc.expected), len(res))
    97  		}
    98  		for bi, b := range res {
    99  			if b.BlockOverrides == nil {
   100  				t.Fatalf("testcase %d: block overrides nil", i)
   101  			}
   102  			if b.BlockOverrides.Number == nil {
   103  				t.Fatalf("testcase %d: block number not set", i)
   104  			}
   105  			if b.BlockOverrides.Time == nil {
   106  				t.Fatalf("testcase %d: block time not set", i)
   107  			}
   108  			if uint64(*b.BlockOverrides.Time) != tc.expected[bi].timestamp {
   109  				t.Errorf("testcase %d: block timestamp mismatch. Want %d, have %d", i, tc.expected[bi].timestamp, uint64(*b.BlockOverrides.Time))
   110  			}
   111  			have := b.BlockOverrides.Number.ToInt().Uint64()
   112  			if have != tc.expected[bi].number {
   113  				t.Errorf("testcase %d: block number mismatch. Want %d, have %d", i, tc.expected[bi].number, have)
   114  			}
   115  		}
   116  	}
   117  }
   118  
   119  func newInt(n int64) *hexutil.Big {
   120  	return (*hexutil.Big)(big.NewInt(n))
   121  }