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

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