piece_test.go

Documentation: github.com/concurrency-8/piece

     1  package piece
     2  
     3  import (
     4  	"github.com/concurrency-8/parser"
     5  	"github.com/stretchr/testify/assert"
     6  	"math/rand"
     7  	"testing"
     8  	// "fmt"
     9  )
    10  
    11  func TestNewPieceTracker(t *testing.T) {
    12  	assert := assert.New(t)
    13  	torrent, _ := parser.ParseFromFile("../test_torrents/big-buck-bunny.torrent")
    14  	tracker := NewPieceTracker(torrent)
    15  	for _, i := range tracker.Requested {
    16  		for _, j := range i {
    17  			assert.Equal(j, false)
    18  		}
    19  	}
    20  
    21  	for _, i := range tracker.Received {
    22  		for _, j := range i {
    23  			assert.Equal(j, false)
    24  		}
    25  	}
    26  }
    27  
    28  func getTorrentBlockTracker() (torrent parser.TorrentFile,
    29  	pieceBlock parser.PieceBlock,
    30  	tracker *PieceTracker) {
    31  	torrent, _ = parser.ParseFromFile("../test_torrents/big-buck-bunny.torrent")
    32  	pieceBlock = parser.RandomPieceBlock(torrent)
    33  	tracker = NewPieceTracker(torrent)
    34  	return
    35  }
    36  
    37  func TestAddRequested(t *testing.T) {
    38  	_, pieceBlock, tracker := getTorrentBlockTracker()
    39  	tracker.AddRequested(pieceBlock)
    40  	assert.Equal(t, true, tracker.Requested[pieceBlock.Index][pieceBlock.Begin/parser.BLOCK_LEN])
    41  }
    42  
    43  func TestAddReceived(t *testing.T) {
    44  	_, pieceBlock, tracker := getTorrentBlockTracker()
    45  	tracker.AddReceived(pieceBlock)
    46  	assert.Equal(t, true, tracker.Received[pieceBlock.Index][pieceBlock.Begin/parser.BLOCK_LEN])
    47  }
    48  
    49  func TestIsDone(t *testing.T) {
    50  	_, _, tracker := getTorrentBlockTracker()
    51  	for _, piece := range tracker.Received {
    52  		for blockIndex := range piece {
    53  			piece[blockIndex] = true
    54  		}
    55  	}
    56  	assert.True(t, tracker.IsDone())
    57  }
    58  
    59  func TestClone(t *testing.T) {
    60  
    61  	// Checking if clone
    62  	src1 := make([][]bool, 5)
    63  	for i := 0; i < 5; i++ {
    64  		src1[i] = make([]bool, 10)
    65  		for j := 0; j < 10; j++ {
    66  			src1[i][j] = rand.Uint32()%2 == 0
    67  		}
    68  	}
    69  	dest1 := clone(src1)
    70  
    71  	for i := range src1 {
    72  		for j := range src1[i] {
    73  			assert.Equal(t, src1[i][j], dest1[i][j])
    74  		}
    75  	}
    76  
    77  	// Checking if deep clone
    78  	src2 := [][]bool{{true}, {true, false}}
    79  	dest2 := clone(src2)
    80  	src2[1][1] = !src2[1][1]
    81  	assert.NotEqual(t, src2[1][1], dest2[1][1])
    82  }
    83  
    84  func TestNeeded(t *testing.T) {
    85  	_, pieceBlock, tracker := getTorrentBlockTracker()
    86  
    87  	assert.True(t, tracker.Needed(pieceBlock))
    88  
    89  	// Checking if the call for needed copies the received array
    90  	// in requested array when all true
    91  	tracker.Requested = [][]bool{{true, true, true}, {true, true, true}}
    92  	tracker.Received = [][]bool{{true, false, false}, {false, false, true}}
    93  
    94  	pieceBlock = parser.PieceBlock{
    95  		Index:   1,
    96  		Begin:   200,
    97  		Length:  1000,
    98  		Nblocks: 3,
    99  	}
   100  
   101  	tracker.Needed(pieceBlock)
   102  
   103  	for i := range tracker.Requested {
   104  		for j := range tracker.Requested[i] {
   105  			assert.Equal(t, tracker.Requested[i][j], tracker.Received[i][j])
   106  		}
   107  	}
   108  }
   109
View as plain text