github.com/ava-labs/subnet-evm@v0.6.4/utils/fork_test.go (about)

     1  // (c) 2019-2020, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package utils
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestIsTimestampForked(t *testing.T) {
    13  	type test struct {
    14  		fork     *uint64
    15  		block    uint64
    16  		isForked bool
    17  	}
    18  
    19  	for name, test := range map[string]test{
    20  		"nil fork at 0": {
    21  			fork:     nil,
    22  			block:    0,
    23  			isForked: false,
    24  		},
    25  		"nil fork at non-zero": {
    26  			fork:     nil,
    27  			block:    100,
    28  			isForked: false,
    29  		},
    30  		"zero fork at genesis": {
    31  			fork:     NewUint64(0),
    32  			block:    0,
    33  			isForked: true,
    34  		},
    35  		"pre fork timestamp": {
    36  			fork:     NewUint64(100),
    37  			block:    50,
    38  			isForked: false,
    39  		},
    40  		"at fork timestamp": {
    41  			fork:     NewUint64(100),
    42  			block:    100,
    43  			isForked: true,
    44  		},
    45  		"post fork timestamp": {
    46  			fork:     NewUint64(100),
    47  			block:    150,
    48  			isForked: true,
    49  		},
    50  	} {
    51  		t.Run(name, func(t *testing.T) {
    52  			res := IsTimestampForked(test.fork, test.block)
    53  			assert.Equal(t, test.isForked, res)
    54  		})
    55  	}
    56  }
    57  
    58  func TestIsForkTransition(t *testing.T) {
    59  	type test struct {
    60  		fork, parent *uint64
    61  		current      uint64
    62  		transitioned bool
    63  	}
    64  
    65  	for name, test := range map[string]test{
    66  		"not active at genesis": {
    67  			fork:         nil,
    68  			parent:       nil,
    69  			current:      0,
    70  			transitioned: false,
    71  		},
    72  		"activate at genesis": {
    73  			fork:         NewUint64(0),
    74  			parent:       nil,
    75  			current:      0,
    76  			transitioned: true,
    77  		},
    78  		"nil fork arbitrary transition": {
    79  			fork:         nil,
    80  			parent:       NewUint64(100),
    81  			current:      101,
    82  			transitioned: false,
    83  		},
    84  		"nil fork transition same timestamp": {
    85  			fork:         nil,
    86  			parent:       NewUint64(100),
    87  			current:      100,
    88  			transitioned: false,
    89  		},
    90  		"exact match on current timestamp": {
    91  			fork:         NewUint64(100),
    92  			parent:       NewUint64(99),
    93  			current:      100,
    94  			transitioned: true,
    95  		},
    96  		"current same as parent does not transition twice": {
    97  			fork:         NewUint64(100),
    98  			parent:       NewUint64(101),
    99  			current:      101,
   100  			transitioned: false,
   101  		},
   102  		"current, parent, and fork same should not transition twice": {
   103  			fork:         NewUint64(100),
   104  			parent:       NewUint64(100),
   105  			current:      100,
   106  			transitioned: false,
   107  		},
   108  		"current transitions after fork": {
   109  			fork:         NewUint64(100),
   110  			parent:       NewUint64(99),
   111  			current:      101,
   112  			transitioned: true,
   113  		},
   114  		"current and parent come after fork": {
   115  			fork:         NewUint64(100),
   116  			parent:       NewUint64(101),
   117  			current:      102,
   118  			transitioned: false,
   119  		},
   120  	} {
   121  		t.Run(name, func(t *testing.T) {
   122  			res := IsForkTransition(test.fork, test.parent, test.current)
   123  			assert.Equal(t, test.transitioned, res)
   124  		})
   125  	}
   126  }