gitlab.com/SiaPrime/SiaPrime@v1.4.1/modules/renter/workerdownload_test.go (about)

     1  package renter
     2  
     3  import (
     4  	"testing"
     5  
     6  	"gitlab.com/NebulousLabs/fastrand"
     7  	"gitlab.com/SiaPrime/SiaPrime/crypto"
     8  	"gitlab.com/SiaPrime/SiaPrime/modules"
     9  	"gitlab.com/SiaPrime/SiaPrime/modules/renter/siafile"
    10  )
    11  
    12  // TestSegmentsForRecovery tests the segmentsForRecovery helper function.
    13  func TestSegmentsForRecovery(t *testing.T) {
    14  	// Test the legacy erasure coder first.
    15  	rscOld, err := siafile.NewRSCode(10, 20)
    16  	if err != nil {
    17  		t.Fatal(err)
    18  	}
    19  	offset := fastrand.Intn(100)
    20  	length := fastrand.Intn(100)
    21  	startSeg, numSeg := segmentsForRecovery(uint64(offset), uint64(length), rscOld)
    22  	if startSeg != 0 || numSeg != modules.SectorSize/crypto.SegmentSize {
    23  		t.Fatal("segmentsForRecovery failed for legacy erasure coder")
    24  	}
    25  
    26  	// Get a new erasure coder and decoded segment size.
    27  	rsc, err := siafile.NewRSSubCode(10, 20, 64)
    28  	if err != nil {
    29  		t.Fatal(err)
    30  	}
    31  
    32  	// Define a function for easier testing.
    33  	assert := func(offset, length, expectedStartSeg, expectedNumSeg uint64) {
    34  		startSeg, numSeg := segmentsForRecovery(offset, length, rsc)
    35  		if startSeg != expectedStartSeg {
    36  			t.Fatalf("wrong startSeg: expected %v but was %v", expectedStartSeg, startSeg)
    37  		}
    38  		if numSeg != expectedNumSeg {
    39  			t.Fatalf("wrong numSeg: expected %v but was %v", expectedNumSeg, numSeg)
    40  		}
    41  	}
    42  
    43  	// Test edge cases within the first segment.
    44  	assert(0, 640, 0, 1)
    45  	assert(1, 639, 0, 1)
    46  	assert(639, 1, 0, 1)
    47  	assert(1, 639, 0, 1)
    48  
    49  	// Same lengths but different offset.
    50  	assert(640, 640, 1, 1)
    51  	assert(641, 639, 1, 1)
    52  	assert(1279, 1, 1, 1)
    53  	assert(641, 639, 1, 1)
    54  
    55  	// Test fetching 2 segments.
    56  	assert(0, 641, 0, 2)
    57  	assert(1, 640, 0, 2)
    58  	assert(640, 641, 1, 2)
    59  	assert(641, 640, 1, 2)
    60  
    61  	// Test fetching 3 segments.
    62  	assert(0, 1281, 0, 3)
    63  	assert(1, 1280, 0, 3)
    64  	assert(1, 1281, 0, 3)
    65  	assert(640, 1281, 1, 3)
    66  	assert(641, 1280, 1, 3)
    67  }
    68  
    69  // TestSectorOffsetAndLength tests the sectorOffsetAndLength helper function.
    70  func TestSectorOffsetAndLength(t *testing.T) {
    71  	// Test the legacy erasure coder first.
    72  	rscOld, err := siafile.NewRSCode(10, 20)
    73  	if err != nil {
    74  		t.Fatal(err)
    75  	}
    76  	offset := fastrand.Intn(100)
    77  	length := fastrand.Intn(100)
    78  	startSeg, numSeg := sectorOffsetAndLength(uint64(offset), uint64(length), rscOld)
    79  	if startSeg != 0 || numSeg != modules.SectorSize {
    80  		t.Fatal("sectorOffsetAndLength failed for legacy erasure coder")
    81  	}
    82  
    83  	// Get a new erasure coder and decoded segment size.
    84  	rsc, err := siafile.NewRSSubCode(10, 20, 64)
    85  	if err != nil {
    86  		t.Fatal(err)
    87  	}
    88  
    89  	// Define a function for easier testing.
    90  	assert := func(offset, length, expectedOffset, expectedLength uint64) {
    91  		o, l := sectorOffsetAndLength(offset, length, rsc)
    92  		if o != expectedOffset {
    93  			t.Fatalf("wrong offset: expected %v but was %v", expectedOffset, o)
    94  		}
    95  		if l != expectedLength {
    96  			t.Fatalf("wrong length: expected %v but was %v", expectedLength, l)
    97  		}
    98  	}
    99  
   100  	// Test edge cases within the first segment.
   101  	assert(0, 640, 0, 64)
   102  	assert(1, 639, 0, 64)
   103  	assert(639, 1, 0, 64)
   104  	assert(1, 639, 0, 64)
   105  
   106  	// Same lengths but different offset.
   107  	assert(640, 640, 64, 64)
   108  	assert(641, 639, 64, 64)
   109  	assert(1279, 1, 64, 64)
   110  	assert(641, 639, 64, 64)
   111  
   112  	// Test fetching 2 segments.
   113  	assert(0, 641, 0, 128)
   114  	assert(1, 640, 0, 128)
   115  	assert(640, 641, 64, 128)
   116  	assert(641, 640, 64, 128)
   117  
   118  	// Test fetching 3 segments.
   119  	assert(0, 1281, 0, 192)
   120  	assert(1, 1280, 0, 192)
   121  	assert(1, 1281, 0, 192)
   122  	assert(640, 1281, 64, 192)
   123  	assert(641, 1280, 64, 192)
   124  }