12 g "github.com/anacrolix/generics"
13 "github.com/anacrolix/log"
14 "github.com/anacrolix/missinggo/v2"
15 "github.com/anacrolix/missinggo/v2/bitmap"
16 qt "github.com/frankban/quicktest"
17 "github.com/stretchr/testify/assert"
18 "github.com/stretchr/testify/require"
20 "github.com/anacrolix/torrent/bencode"
21 "github.com/anacrolix/torrent/internal/testutil"
22 "github.com/anacrolix/torrent/metainfo"
23 pp "github.com/anacrolix/torrent/peer_protocol"
24 "github.com/anacrolix/torrent/storage"
27 func r(i, b, l pp.Integer) Request {
28 return Request{i, ChunkSpec{b, l}}
31 // Check the given request is correct for various torrent offsets.
32 func TestTorrentRequest(t *testing.T) {
33 const s = 472183431 // Length of torrent.
34 for _, _case := range []struct {
35 off int64 // An offset into the torrent.
36 req Request // The expected request. The zero value means !ok.
41 // One before the end of a piece.
42 {1<<18 - 1, r(0, 1<<18-16384, 16384)},
43 // Offset beyond torrent length.
44 {472 * 1 << 20, Request{}},
45 // One before the end of the torrent. Complicates the chunk length.
46 {s - 1, r((s-1)/(1<<18), (s-1)%(1<<18)/(16384)*(16384), 12935)},
48 // One before end of chunk.
49 {16383, r(0, 0, 16384)},
51 {16384, r(0, 16384, 16384)},
53 req, ok := torrentOffsetRequest(472183431, 1<<18, 16384, _case.off)
54 if (_case.req == Request{}) == ok {
55 t.Fatalf("expected %v, got %v", _case.req, req)
58 t.Fatalf("expected %v, got %v", _case.req, req)
63 func TestAppendToCopySlice(t *testing.T) {
64 orig := []int{1, 2, 3}
65 dupe := append([]int{}, orig...)
72 func TestTorrentString(t *testing.T) {
74 tor.infoHash.Ok = true
75 tor.infoHash.Value[0] = 1
76 s := tor.InfoHash().HexString()
77 if s != "0100000000000000000000000000000000000000" {
82 // This benchmark is from the observation that a lot of overlapping Readers on
83 // a large torrent with small pieces had a lot of overhead in recalculating
84 // piece priorities everytime a reader (possibly in another Torrent) changed.
85 func BenchmarkUpdatePiecePriorities(b *testing.B) {
88 pieceLength = 256 << 10
90 cl := &Client{config: TestingConfig(b)}
92 t := cl.newTorrentForTesting()
93 require.NoError(b, t.setInfo(&metainfo.Info{
94 Pieces: make([]byte, metainfo.HashSize*numPieces),
95 PieceLength: pieceLength,
96 Length: pieceLength * numPieces,
99 assert.EqualValues(b, 13410, t.numPieces())
100 for i := 0; i < 7; i += 1 {
102 r.SetReadahead(32 << 20)
103 r.Seek(3500000, io.SeekStart)
105 assert.Len(b, t.readers, 7)
106 for i := 0; i < t.numPieces(); i += 3 {
107 t._completedPieces.Add(bitmap.BitIndex(i))
109 t.DownloadPieces(0, t.numPieces())
110 for i := 0; i < b.N; i += 1 {
111 t.updateAllPiecePriorities("")
115 // Check that a torrent containing zero-length file(s) will start, and that
116 // they're created in the filesystem. The client storage is assumed to be
117 // file-based on the native filesystem based.
118 func testEmptyFilesAndZeroPieceLength(t *testing.T, cfg *ClientConfig) {
119 cl, err := NewClient(cfg)
120 require.NoError(t, err)
122 ib, err := bencode.Marshal(metainfo.Info{
127 require.NoError(t, err)
128 fp := filepath.Join(cfg.DataDir, "empty")
130 assert.False(t, missinggo.FilePathExists(fp))
131 tt, err := cl.AddTorrent(&metainfo.MetaInfo{
134 require.NoError(t, err)
137 require.True(t, cl.WaitAll())
138 assert.True(t, tt.Complete.Bool())
139 assert.True(t, missinggo.FilePathExists(fp))
142 func TestEmptyFilesAndZeroPieceLengthWithFileStorage(t *testing.T) {
143 cfg := TestingConfig(t)
144 ci := storage.NewFile(cfg.DataDir)
146 cfg.DefaultStorage = ci
147 testEmptyFilesAndZeroPieceLength(t, cfg)
150 func TestPieceHashFailed(t *testing.T) {
151 mi := testutil.GreetingMetaInfo()
152 cl := newTestingClient(t)
153 tt := cl.newTorrent(mi.HashInfoBytes(), badStorage{})
155 require.NoError(t, tt.setInfoBytesLocked(mi.InfoBytes))
157 tt.dirtyChunks.AddRange(
158 uint64(tt.pieceRequestIndexOffset(1)),
159 uint64(tt.pieceRequestIndexOffset(1)+3))
160 require.True(t, tt.pieceAllDirty(1))
161 tt.pieceHashed(1, false, nil)
162 // Dirty chunks should be cleared so we can try again.
163 require.False(t, tt.pieceAllDirty(1))
167 // Check the behaviour of Torrent.Metainfo when metadata is not completed.
168 func TestTorrentMetainfoIncompleteMetadata(t *testing.T) {
169 cfg := TestingConfig(t)
171 // Disable this just because we manually initiate a connection without it.
172 cfg.MinPeerExtensions.SetBit(pp.ExtensionBitFast, false)
173 cl, err := NewClient(cfg)
174 require.NoError(t, err)
177 mi := testutil.GreetingMetaInfo()
178 ih := mi.HashInfoBytes()
180 tt, _ := cl.AddTorrentInfoHash(ih)
181 assert.Nil(t, tt.Metainfo().InfoBytes)
182 assert.False(t, tt.haveAllMetadataPieces())
184 nc, err := net.Dial("tcp", fmt.Sprintf(":%d", cl.LocalPort()))
185 require.NoError(t, err)
188 var pex PeerExtensionBits
189 pex.SetBit(pp.ExtensionBitLtep, true)
190 hr, err := pp.Handshake(nc, &ih, [20]byte{}, pex)
191 require.NoError(t, err)
192 assert.True(t, hr.PeerExtensionBits.GetBit(pp.ExtensionBitLtep))
193 assert.EqualValues(t, cl.PeerID(), hr.PeerID)
194 assert.EqualValues(t, ih, hr.Hash)
196 assert.EqualValues(t, 0, tt.metadataSize())
202 _, err = nc.Write(pp.Message{
204 ExtendedID: pp.HandshakeExtendedID,
205 ExtendedPayload: func() []byte {
206 d := map[string]interface{}{
207 "metadata_size": len(mi.InfoBytes),
209 b, err := bencode.Marshal(d)
215 }.MustMarshalBinary())
216 require.NoError(t, err)
218 tt.metadataChanged.Wait()
220 assert.Equal(t, make([]byte, len(mi.InfoBytes)), tt.metadataBytes)
221 assert.False(t, tt.haveAllMetadataPieces())
222 assert.Nil(t, tt.Metainfo().InfoBytes)
225 func TestRelativeAvailabilityHaveNone(t *testing.T) {
229 config: TestingConfig(t),
234 gotMetainfoC: make(chan struct{}),
237 g.MakeMapIfNil(&tt.conns)
241 pc.initRequestState()
242 g.InitNew(&pc.callbacks)
243 tt.conns[&pc] = struct{}{}
244 err = pc.peerSentHave(0)
245 c.Assert(err, qt.IsNil)
246 info := testutil.Greeting.Info(5)
247 err = tt.setInfo(&info)
248 c.Assert(err, qt.IsNil)
250 err = pc.peerSentHaveNone()
251 c.Assert(err, qt.IsNil)
252 var wg sync.WaitGroup
254 tt.assertAllPiecesRelativeAvailabilityZero()