github.com/filecoin-project/specs-actors/v4@v4.0.2/actors/builtin/miner/sector_map_test.go (about)

     1  package miner_test
     2  
     3  import (
     4  	"errors"
     5  	"math"
     6  	"sort"
     7  	"testing"
     8  
     9  	"github.com/filecoin-project/go-bitfield"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  
    13  	"github.com/filecoin-project/specs-actors/v4/actors/builtin/miner"
    14  )
    15  
    16  func TestDeadlineSectorMap(t *testing.T) {
    17  	dm := make(miner.DeadlineSectorMap)
    18  	dlCount := uint64(10)
    19  	partCount := uint64(5)
    20  	for dlIdx := uint64(0); dlIdx < dlCount; dlIdx++ {
    21  		for partIdx := uint64(0); partIdx < partCount; partIdx++ {
    22  			assert.NoError(t, dm.Add(dlIdx, partIdx, bf(dlIdx*partCount+partIdx)))
    23  		}
    24  	}
    25  
    26  	err := dm.ForEach(func(dlIdx uint64, partitions miner.PartitionSectorMap) error {
    27  		assert.Equal(t, dm[dlIdx], partitions)
    28  		return partitions.ForEach(func(partIdx uint64, sectorNos bitfield.BitField) error {
    29  			assert.Equal(t, partitions[partIdx], sectorNos)
    30  			assertBitfieldEquals(t, sectorNos, dlIdx*partCount+partIdx)
    31  			return nil
    32  		})
    33  	})
    34  	require.NoError(t, err)
    35  
    36  	// check all counts.
    37  	parts, sectors, err := dm.Count()
    38  	require.NoError(t, err)
    39  	assert.Equal(t, parts, partCount*dlCount)
    40  	assert.Equal(t, sectors, partCount*dlCount)
    41  	assert.Error(t, dm.Check(1, 1))
    42  	assert.Error(t, dm.Check(100, 1))
    43  	assert.Error(t, dm.Check(1, 100))
    44  	assert.NoError(t, dm.Check(partCount*dlCount, partCount*dlCount))
    45  
    46  	// Merge a sector in.
    47  	require.NoError(t, dm.Add(0, 0, bf(1000)))
    48  	assertBitfieldEquals(t, dm[0][0], 0, 1000)
    49  	assert.Error(t, dm.Check(partCount*dlCount, partCount*dlCount))
    50  	assert.NoError(t, dm.Check(partCount*dlCount, partCount*dlCount+1))
    51  }
    52  
    53  func TestDeadlineSectorMapError(t *testing.T) {
    54  	dm := make(miner.DeadlineSectorMap)
    55  	dlCount := uint64(10)
    56  	partCount := uint64(5)
    57  	for dlIdx := uint64(0); dlIdx < dlCount; dlIdx++ {
    58  		for partIdx := uint64(0); partIdx < partCount; partIdx++ {
    59  			assert.NoError(t, dm.Add(dlIdx, partIdx, bf(dlIdx*partCount+partIdx)))
    60  		}
    61  	}
    62  
    63  	expErr := errors.New("foobar")
    64  
    65  	err := dm.ForEach(func(dlIdx uint64, partitions miner.PartitionSectorMap) error {
    66  		return partitions.ForEach(func(partIdx uint64, sectorNos bitfield.BitField) error {
    67  			return expErr
    68  		})
    69  	})
    70  	require.Equal(t, expErr, err)
    71  }
    72  
    73  func TestDeadlineSectorMapValues(t *testing.T) {
    74  	dm := make(miner.DeadlineSectorMap)
    75  	assert.NoError(t, dm.AddValues(0, 1, 0, 1, 2, 3))
    76  
    77  	assertBitfieldEquals(t, dm[0][1], 0, 1, 2, 3)
    78  }
    79  
    80  func TestPartitionSectorMapValues(t *testing.T) {
    81  	pm := make(miner.PartitionSectorMap)
    82  	assert.NoError(t, pm.AddValues(0, 0, 1, 2, 3))
    83  
    84  	assertBitfieldEquals(t, pm[0], 0, 1, 2, 3)
    85  }
    86  
    87  func TestDeadlineSectorMapOverflow(t *testing.T) {
    88  	dm := make(miner.DeadlineSectorMap)
    89  	dlCount := uint64(10)
    90  	bf := seq(t, 0, math.MaxUint64)
    91  	for dlIdx := uint64(0); dlIdx < dlCount; dlIdx++ {
    92  		assert.NoError(t, dm.Add(dlIdx, 0, bf))
    93  	}
    94  
    95  	_, _, err := dm[0].Count()
    96  	require.NoError(t, err)
    97  
    98  	_, _, err = dm.Count()
    99  	require.Error(t, err)
   100  }
   101  
   102  func TestPartitionSectorMapOverflow(t *testing.T) {
   103  	pm := make(miner.PartitionSectorMap)
   104  	partCount := uint64(2)
   105  	bf := seq(t, 0, math.MaxUint64)
   106  	for partIdx := uint64(0); partIdx < partCount; partIdx++ {
   107  		assert.NoError(t, pm.Add(partIdx, bf))
   108  	}
   109  
   110  	_, _, err := pm.Count()
   111  	require.Error(t, err)
   112  }
   113  
   114  func TestDeadlineSectorMapEmpty(t *testing.T) {
   115  	var dm miner.DeadlineSectorMap
   116  	partitions, sectors, err := dm.Count()
   117  	require.NoError(t, err)
   118  	require.Zero(t, partitions)
   119  	require.Zero(t, sectors)
   120  
   121  	require.NoError(t, dm.ForEach(func(dlIdx uint64, pm miner.PartitionSectorMap) error {
   122  		require.Fail(t, "should not iterate over an empty map")
   123  		return nil
   124  	}))
   125  	require.Empty(t, dm.Deadlines())
   126  }
   127  
   128  func TestPartitionSectorMapEmpty(t *testing.T) {
   129  	var pm miner.PartitionSectorMap
   130  
   131  	partitions, sectors, err := pm.Count()
   132  	require.NoError(t, err)
   133  	require.Zero(t, partitions)
   134  	require.Zero(t, sectors)
   135  
   136  	require.NoError(t, pm.ForEach(func(dlIdx uint64, sectorNos bitfield.BitField) error {
   137  		require.Fail(t, "should not iterate over an empty map")
   138  		return nil
   139  	}))
   140  	require.Empty(t, pm.Partitions())
   141  }
   142  
   143  func TestDeadlineSectorMapSorted(t *testing.T) {
   144  	dm := make(miner.DeadlineSectorMap)
   145  	for i := uint64(47); i > 0; i-- {
   146  		require.NoError(t, dm.AddValues(i, 0, 0))
   147  	}
   148  	dls := dm.Deadlines()
   149  	require.True(t, sort.SliceIsSorted(dls, func(i, j int) bool {
   150  		return dls[i] < dls[j]
   151  	}))
   152  }
   153  
   154  func TestPartitionSectorMapSorted(t *testing.T) {
   155  	pm := make(miner.PartitionSectorMap)
   156  	for i := uint64(100); i > 0; i-- {
   157  		require.NoError(t, pm.AddValues(i, 0))
   158  	}
   159  	pms := pm.Partitions()
   160  	require.True(t, sort.SliceIsSorted(pms, func(i, j int) bool {
   161  		return pms[i] < pms[j]
   162  	}))
   163  }