github.com/MetalBlockchain/metalgo@v1.11.9/vms/platformvm/state/merged_iterator_test.go (about)

     1  // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package state
     5  
     6  import (
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/MetalBlockchain/metalgo/ids"
    13  )
    14  
    15  func TestMergedIterator(t *testing.T) {
    16  	type test struct {
    17  		name      string
    18  		iterators []StakerIterator
    19  		expected  []*Staker
    20  	}
    21  
    22  	txID := ids.GenerateTestID()
    23  	tests := []test{
    24  		{
    25  			name:      "no iterators",
    26  			iterators: []StakerIterator{},
    27  			expected:  []*Staker{},
    28  		},
    29  		{
    30  			name:      "one empty iterator",
    31  			iterators: []StakerIterator{EmptyIterator},
    32  			expected:  []*Staker{},
    33  		},
    34  		{
    35  			name:      "multiple empty iterator",
    36  			iterators: []StakerIterator{EmptyIterator, EmptyIterator, EmptyIterator},
    37  			expected:  []*Staker{},
    38  		},
    39  		{
    40  			name:      "mixed empty iterators",
    41  			iterators: []StakerIterator{EmptyIterator, NewSliceIterator()},
    42  			expected:  []*Staker{},
    43  		},
    44  		{
    45  			name: "single iterator",
    46  			iterators: []StakerIterator{
    47  				NewSliceIterator(
    48  					&Staker{
    49  						TxID:     txID,
    50  						NextTime: time.Unix(0, 0),
    51  					},
    52  					&Staker{
    53  						TxID:     txID,
    54  						NextTime: time.Unix(1, 0),
    55  					},
    56  				),
    57  			},
    58  			expected: []*Staker{
    59  				{
    60  					TxID:     txID,
    61  					NextTime: time.Unix(0, 0),
    62  				},
    63  				{
    64  					TxID:     txID,
    65  					NextTime: time.Unix(1, 0),
    66  				},
    67  			},
    68  		},
    69  		{
    70  			name: "multiple iterators",
    71  			iterators: []StakerIterator{
    72  				NewSliceIterator(
    73  					&Staker{
    74  						TxID:     txID,
    75  						NextTime: time.Unix(0, 0),
    76  					},
    77  					&Staker{
    78  						TxID:     txID,
    79  						NextTime: time.Unix(2, 0),
    80  					},
    81  				),
    82  				NewSliceIterator(
    83  					&Staker{
    84  						TxID:     txID,
    85  						NextTime: time.Unix(1, 0),
    86  					},
    87  					&Staker{
    88  						TxID:     txID,
    89  						NextTime: time.Unix(3, 0),
    90  					},
    91  				),
    92  			},
    93  			expected: []*Staker{
    94  				{
    95  					TxID:     txID,
    96  					NextTime: time.Unix(0, 0),
    97  				},
    98  				{
    99  					TxID:     txID,
   100  					NextTime: time.Unix(1, 0),
   101  				},
   102  				{
   103  					TxID:     txID,
   104  					NextTime: time.Unix(2, 0),
   105  				},
   106  				{
   107  					TxID:     txID,
   108  					NextTime: time.Unix(3, 0),
   109  				},
   110  			},
   111  		},
   112  		{
   113  			name: "multiple iterators different lengths",
   114  			iterators: []StakerIterator{
   115  				NewSliceIterator(
   116  					&Staker{
   117  						TxID:     txID,
   118  						NextTime: time.Unix(0, 0),
   119  					},
   120  					&Staker{
   121  						TxID:     txID,
   122  						NextTime: time.Unix(2, 0),
   123  					},
   124  				),
   125  				NewSliceIterator(
   126  					&Staker{
   127  						TxID:     txID,
   128  						NextTime: time.Unix(1, 0),
   129  					},
   130  					&Staker{
   131  						TxID:     txID,
   132  						NextTime: time.Unix(3, 0),
   133  					},
   134  					&Staker{
   135  						TxID:     txID,
   136  						NextTime: time.Unix(4, 0),
   137  					},
   138  					&Staker{
   139  						TxID:     txID,
   140  						NextTime: time.Unix(5, 0),
   141  					},
   142  				),
   143  			},
   144  			expected: []*Staker{
   145  				{
   146  					TxID:     txID,
   147  					NextTime: time.Unix(0, 0),
   148  				},
   149  				{
   150  					TxID:     txID,
   151  					NextTime: time.Unix(1, 0),
   152  				},
   153  				{
   154  					TxID:     txID,
   155  					NextTime: time.Unix(2, 0),
   156  				},
   157  				{
   158  					TxID:     txID,
   159  					NextTime: time.Unix(3, 0),
   160  				},
   161  				{
   162  					TxID:     txID,
   163  					NextTime: time.Unix(4, 0),
   164  				},
   165  				{
   166  					TxID:     txID,
   167  					NextTime: time.Unix(5, 0),
   168  				},
   169  			},
   170  		},
   171  	}
   172  
   173  	for _, tt := range tests {
   174  		t.Run(tt.name, func(t *testing.T) {
   175  			require := require.New(t)
   176  			it := NewMergedIterator(tt.iterators...)
   177  			for _, expected := range tt.expected {
   178  				require.True(it.Next())
   179  				require.Equal(expected, it.Value())
   180  			}
   181  			require.False(it.Next())
   182  			it.Release()
   183  			require.False(it.Next())
   184  		})
   185  	}
   186  }
   187  
   188  func TestMergedIteratorEarlyRelease(t *testing.T) {
   189  	require := require.New(t)
   190  	stakers0 := []*Staker{
   191  		{
   192  			TxID:     ids.GenerateTestID(),
   193  			NextTime: time.Unix(0, 0),
   194  		},
   195  		{
   196  			TxID:     ids.GenerateTestID(),
   197  			NextTime: time.Unix(2, 0),
   198  		},
   199  	}
   200  
   201  	stakers1 := []*Staker{
   202  		{
   203  			TxID:     ids.GenerateTestID(),
   204  			NextTime: time.Unix(1, 0),
   205  		},
   206  		{
   207  			TxID:     ids.GenerateTestID(),
   208  			NextTime: time.Unix(3, 0),
   209  		},
   210  	}
   211  
   212  	it := NewMergedIterator(
   213  		EmptyIterator,
   214  		NewSliceIterator(stakers0...),
   215  		EmptyIterator,
   216  		NewSliceIterator(stakers1...),
   217  		EmptyIterator,
   218  	)
   219  	require.True(it.Next())
   220  	it.Release()
   221  	require.False(it.Next())
   222  }