torrent_test.go

   1 package torrent
   2
   3 import (
   4         "fmt"
   5         "io"
   6         "net"
   7         "os"
   8         "path/filepath"
   9         "testing"
  10
  11         "github.com/anacrolix/missinggo"
  12         "github.com/anacrolix/missinggo/v2/bitmap"
  13         "github.com/bradfitz/iter"
  14         "github.com/stretchr/testify/assert"
  15         "github.com/stretchr/testify/require"
  16
  17         "github.com/anacrolix/torrent/bencode"
  18         "github.com/anacrolix/torrent/internal/testutil"
  19         "github.com/anacrolix/torrent/metainfo"
  20         pp "github.com/anacrolix/torrent/peer_protocol"
  21         "github.com/anacrolix/torrent/storage"
  22 )
  23
  24 func r(i, b, l pp.Integer) Request {
  25         return Request{i, ChunkSpec{b, l}}
  26 }
  27
  28 // Check the given request is correct for various torrent offsets.
  29 func TestTorrentRequest(t *testing.T) {
  30         const s = 472183431 // Length of torrent.
  31         for _, _case := range []struct {
  32                 off int64   // An offset into the torrent.
  33                 req Request // The expected request. The zero value means !ok.
  34         }{
  35                 // Invalid offset.
  36                 {-1, Request{}},
  37                 {0, r(0, 0, 16384)},
  38                 // One before the end of a piece.
  39                 {1<<18 - 1, r(0, 1<<18-16384, 16384)},
  40                 // Offset beyond torrent length.
  41                 {472 * 1 << 20, Request{}},
  42                 // One before the end of the torrent. Complicates the chunk length.
  43                 {s - 1, r((s-1)/(1<<18), (s-1)%(1<<18)/(16384)*(16384), 12935)},
  44                 {1, r(0, 0, 16384)},
  45                 // One before end of chunk.
  46                 {16383, r(0, 0, 16384)},
  47                 // Second chunk.
  48                 {16384, r(0, 16384, 16384)},
  49         } {
  50                 req, ok := torrentOffsetRequest(472183431, 1<<18, 16384, _case.off)
  51                 if (_case.req == Request{}) == ok {
  52                         t.Fatalf("expected %v, got %v", _case.req, req)
  53                 }
  54                 if req != _case.req {
  55                         t.Fatalf("expected %v, got %v", _case.req, req)
  56                 }
  57         }
  58 }
  59
  60 func TestAppendToCopySlice(t *testing.T) {
  61         orig := []int{1, 2, 3}
  62         dupe := append([]int{}, orig...)
  63         dupe[0] = 4
  64         if orig[0] != 1 {
  65                 t.FailNow()
  66         }
  67 }
  68
  69 func TestTorrentString(t *testing.T) {
  70         tor := &Torrent{}
  71         s := tor.InfoHash().HexString()
  72         if s != "0000000000000000000000000000000000000000" {
  73                 t.FailNow()
  74         }
  75 }
  76
  77 // This benchmark is from the observation that a lot of overlapping Readers on
  78 // a large torrent with small pieces had a lot of overhead in recalculating
  79 // piece priorities everytime a reader (possibly in another Torrent) changed.
  80 func BenchmarkUpdatePiecePriorities(b *testing.B) {
  81         const (
  82                 numPieces   = 13410
  83                 pieceLength = 256 << 10
  84         )
  85         cl := &Client{config: TestingConfig(b)}
  86         cl.initLogger()
  87         t := cl.newTorrent(metainfo.Hash{}, nil)
  88         require.NoError(b, t.setInfo(&metainfo.Info{
  89                 Pieces:      make([]byte, metainfo.HashSize*numPieces),
  90                 PieceLength: pieceLength,
  91                 Length:      pieceLength * numPieces,
  92         }))
  93         assert.EqualValues(b, 13410, t.numPieces())
  94         for range iter.N(7) {
  95                 r := t.NewReader()
  96                 r.SetReadahead(32 << 20)
  97                 r.Seek(3500000, io.SeekStart)
  98         }
  99         assert.Len(b, t.readers, 7)
 100         for i := 0; i < t.numPieces(); i += 3 {
 101                 t._completedPieces.Set(bitmap.BitIndex(i), true)
 102         }
 103         t.DownloadPieces(0, t.numPieces())
 104         for range iter.N(b.N) {
 105                 t.updateAllPiecePriorities()
 106         }
 107 }
 108
 109 // Check that a torrent containing zero-length file(s) will start, and that
 110 // they're created in the filesystem. The client storage is assumed to be
 111 // file-based on the native filesystem based.
 112 func testEmptyFilesAndZeroPieceLength(t *testing.T, cfg *ClientConfig) {
 113         cl, err := NewClient(cfg)
 114         require.NoError(t, err)
 115         defer cl.Close()
 116         ib, err := bencode.Marshal(metainfo.Info{
 117                 Name:        "empty",
 118                 Length:      0,
 119                 PieceLength: 0,
 120         })
 121         require.NoError(t, err)
 122         fp := filepath.Join(cfg.DataDir, "empty")
 123         os.Remove(fp)
 124         assert.False(t, missinggo.FilePathExists(fp))
 125         tt, err := cl.AddTorrent(&metainfo.MetaInfo{
 126                 InfoBytes: ib,
 127         })
 128         require.NoError(t, err)
 129         defer tt.Drop()
 130         tt.DownloadAll()
 131         require.True(t, cl.WaitAll())
 132         assert.True(t, missinggo.FilePathExists(fp))
 133 }
 134
 135 func TestEmptyFilesAndZeroPieceLengthWithFileStorage(t *testing.T) {
 136         cfg := TestingConfig(t)
 137         ci := storage.NewFile(cfg.DataDir)
 138         defer ci.Close()
 139         cfg.DefaultStorage = ci
 140         testEmptyFilesAndZeroPieceLength(t, cfg)
 141 }
 142
 143 func TestEmptyFilesAndZeroPieceLengthWithMMapStorage(t *testing.T) {
 144         cfg := TestingConfig(t)
 145         ci := storage.NewMMap(cfg.DataDir)
 146         defer ci.Close()
 147         cfg.DefaultStorage = ci
 148         testEmptyFilesAndZeroPieceLength(t, cfg)
 149 }
 150
 151 func TestPieceHashFailed(t *testing.T) {
 152         mi := testutil.GreetingMetaInfo()
 153         cl := new(Client)
 154         cl.config = TestingConfig(t)
 155         cl.initLogger()
 156         tt := cl.newTorrent(mi.HashInfoBytes(), badStorage{})
 157         tt.setChunkSize(2)
 158         require.NoError(t, tt.setInfoBytes(mi.InfoBytes))
 159         tt.cl.lock()
 160         tt.pieces[1]._dirtyChunks.AddRange(0, 3)
 161         require.True(t, tt.pieceAllDirty(1))
 162         tt.pieceHashed(1, false, nil)
 163         // Dirty chunks should be cleared so we can try again.
 164         require.False(t, tt.pieceAllDirty(1))
 165         tt.cl.unlock()
 166 }
 167
 168 // Check the behaviour of Torrent.Metainfo when metadata is not completed.
 169 func TestTorrentMetainfoIncompleteMetadata(t *testing.T) {
 170         cfg := TestingConfig(t)
 171         cfg.Debug = true
 172         cl, err := NewClient(cfg)
 173         require.NoError(t, err)
 174         defer cl.Close()
 175
 176         mi := testutil.GreetingMetaInfo()
 177         ih := mi.HashInfoBytes()
 178
 179         tt, _ := cl.AddTorrentInfoHash(ih)
 180         assert.Nil(t, tt.Metainfo().InfoBytes)
 181         assert.False(t, tt.haveAllMetadataPieces())
 182
 183         nc, err := net.Dial("tcp", fmt.Sprintf(":%d", cl.LocalPort()))
 184         require.NoError(t, err)
 185         defer nc.Close()
 186
 187         var pex PeerExtensionBits
 188         pex.SetBit(pp.ExtensionBitExtended, true)
 189         hr, err := pp.Handshake(nc, &ih, [20]byte{}, pex)
 190         require.NoError(t, err)
 191         assert.True(t, hr.PeerExtensionBits.GetBit(pp.ExtensionBitExtended))
 192         assert.EqualValues(t, cl.PeerID(), hr.PeerID)
 193         assert.EqualValues(t, ih, hr.Hash)
 194
 195         assert.EqualValues(t, 0, tt.metadataSize())
 196
 197         func() {
 198                 cl.lock()
 199                 defer cl.unlock()
 200                 go func() {
 201                         _, err = nc.Write(pp.Message{
 202                                 Type:       pp.Extended,
 203                                 ExtendedID: pp.HandshakeExtendedID,
 204                                 ExtendedPayload: func() []byte {
 205                                         d := map[string]interface{}{
 206                                                 "metadata_size": len(mi.InfoBytes),
 207                                         }
 208                                         b, err := bencode.Marshal(d)
 209                                         if err != nil {
 210                                                 panic(err)
 211                                         }
 212                                         return b
 213                                 }(),
 214                         }.MustMarshalBinary())
 215                         require.NoError(t, err)
 216                 }()
 217                 tt.metadataChanged.Wait()
 218         }()
 219         assert.Equal(t, make([]byte, len(mi.InfoBytes)), tt.metadataBytes)
 220         assert.False(t, tt.haveAllMetadataPieces())
 221         assert.Nil(t, tt.Metainfo().InfoBytes)
 222 }