github.com/anacrolix/torrent@v1.61.0/segments/segments_test.go (about)

     1  package segments
     2  
     3  import (
     4  	"slices"
     5  	"testing"
     6  
     7  	"github.com/go-quicktest/qt"
     8  )
     9  
    10  func LengthIterFromSlice(ls []Length) LengthIter {
    11  	return slices.Values(ls)
    12  }
    13  
    14  type ScanCallbackValue struct {
    15  	Index int
    16  	Extent
    17  }
    18  
    19  type collectExtents []ScanCallbackValue
    20  
    21  func (me *collectExtents) scanCallback(i int, e Extent) bool {
    22  	*me = append(*me, ScanCallbackValue{
    23  		Index:  i,
    24  		Extent: e,
    25  	})
    26  	return true
    27  }
    28  
    29  type newLocater func(LengthIter) Locater
    30  
    31  func checkContiguous(
    32  	t *testing.T,
    33  	nl newLocater,
    34  	ls []Length,
    35  	needle Extent,
    36  	firstExpectedIndex int,
    37  	expectedExtents []Extent,
    38  ) {
    39  	var actual collectExtents
    40  	var expected collectExtents
    41  	for i, e := range expectedExtents {
    42  		expected.scanCallback(firstExpectedIndex+i, e)
    43  	}
    44  	nl(LengthIterFromSlice(ls))(needle, actual.scanCallback)
    45  	qt.Check(t, qt.DeepEquals(actual, expected))
    46  }
    47  
    48  func testLocater(t *testing.T, newLocater newLocater) {
    49  	checkContiguous(t, newLocater,
    50  		[]Length{1, 0, 2, 0, 3},
    51  		Extent{2, 2},
    52  		2,
    53  		[]Extent{{1, 1}, {0, 0}, {0, 1}})
    54  	checkContiguous(t, newLocater,
    55  		[]Length{1, 0, 2, 0, 3},
    56  		Extent{6, 2},
    57  		2,
    58  		[]Extent{})
    59  	checkContiguous(t, newLocater,
    60  		[]Length{1652, 1514, 1554, 1618, 1546, 129241752, 1537}, // 128737588
    61  		Extent{0, 16384},
    62  		0,
    63  		[]Extent{
    64  			{0, 1652},
    65  			{0, 1514},
    66  			{0, 1554},
    67  			{0, 1618},
    68  			{0, 1546},
    69  			{0, 8500},
    70  		})
    71  	checkContiguous(t, newLocater,
    72  		[]Length{1652, 1514, 1554, 1618, 1546, 129241752, 1537, 1536, 1551}, // 128737588
    73  		Extent{129236992, 16384},
    74  		5,
    75  		[]Extent{
    76  			{129229108, 12644},
    77  			{0, 1537},
    78  			{0, 1536},
    79  			{0, 667},
    80  		})
    81  	checkContiguous(t, newLocater,
    82  		[]Length{0, 2, 0, 2, 0}, // 128737588
    83  		Extent{1, 2},
    84  		1,
    85  		[]Extent{
    86  			{1, 1},
    87  			{0, 0},
    88  			{0, 1},
    89  		})
    90  	checkContiguous(t, newLocater,
    91  		[]Length{2, 0, 2, 0}, // 128737588
    92  		Extent{1, 3},
    93  		0,
    94  		[]Extent{
    95  			{1, 1},
    96  			{0, 0},
    97  			{0, 2},
    98  		})
    99  	checkContiguous(t, newLocater,
   100  		[]Length{2, 0, 1, 0, 0, 1},
   101  		Extent{3, 2},
   102  		5,
   103  		[]Extent{
   104  			{0, 1},
   105  		})
   106  	checkContiguous(t, newLocater,
   107  		[]Length{2, 0, 1, 0, 0, 1},
   108  		Extent{2, 2},
   109  		2,
   110  		[]Extent{
   111  			{0, 1},
   112  			{0, 0},
   113  			{0, 0},
   114  			{0, 1},
   115  		})
   116  	checkContiguous(t, newLocater,
   117  		[]Length{},
   118  		Extent{1, 1},
   119  		0,
   120  		[]Extent{})
   121  	checkContiguous(t, newLocater,
   122  		[]Length{0},
   123  		Extent{1, 1},
   124  		0,
   125  		[]Extent{})
   126  }
   127  
   128  func TestIndexLocateIter(t *testing.T) {
   129  	testLocater(t, func(li LengthIter) Locater {
   130  		index := NewIndex(li)
   131  		return func(extent Extent, callback Callback) bool {
   132  			for i, e := range index.LocateIter(extent) {
   133  				if !callback(i, e) {
   134  					return false
   135  				}
   136  			}
   137  			return true
   138  		}
   139  	})
   140  }