gitlab.com/SkynetLabs/skyd@v1.6.9/skymodules/renter/downloadchunk_test.go (about)

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