9 "github.com/anacrolix/missinggo"
10 "github.com/bradfitz/iter"
11 "github.com/stretchr/testify/assert"
12 "github.com/stretchr/testify/require"
14 "github.com/anacrolix/torrent/bencode"
15 "github.com/anacrolix/torrent/internal/testutil"
16 "github.com/anacrolix/torrent/metainfo"
17 pp "github.com/anacrolix/torrent/peer_protocol"
18 "github.com/anacrolix/torrent/storage"
21 func r(i, b, l pp.Integer) request {
22 return request{i, chunkSpec{b, l}}
25 // Check the given Request is correct for various torrent offsets.
26 func TestTorrentRequest(t *testing.T) {
27 const s = 472183431 // Length of torrent.
28 for _, _case := range []struct {
29 off int64 // An offset into the torrent.
30 req request // The expected Request. The zero value means !ok.
35 // One before the end of a piece.
36 {1<<18 - 1, r(0, 1<<18-16384, 16384)},
37 // Offset beyond torrent length.
38 {472 * 1 << 20, request{}},
39 // One before the end of the torrent. Complicates the chunk length.
40 {s - 1, r((s-1)/(1<<18), (s-1)%(1<<18)/(16384)*(16384), 12935)},
42 // One before end of chunk.
43 {16383, r(0, 0, 16384)},
45 {16384, r(0, 16384, 16384)},
47 req, ok := torrentOffsetRequest(472183431, 1<<18, 16384, _case.off)
48 if (_case.req == request{}) == ok {
49 t.Fatalf("expected %v, got %v", _case.req, req)
52 t.Fatalf("expected %v, got %v", _case.req, req)
57 func TestAppendToCopySlice(t *testing.T) {
58 orig := []int{1, 2, 3}
59 dupe := append([]int{}, orig...)
66 func TestTorrentString(t *testing.T) {
68 s := tor.InfoHash().HexString()
69 if s != "0000000000000000000000000000000000000000" {
74 // This benchmark is from the observation that a lot of overlapping Readers on
75 // a large torrent with small pieces had a lot of overhead in recalculating
76 // piece priorities everytime a reader (possibly in another Torrent) changed.
77 func BenchmarkUpdatePiecePriorities(b *testing.B) {
79 t := cl.newTorrent(metainfo.Hash{}, nil)
80 t.info = &metainfo.Info{
81 Pieces: make([]byte, 20*13410),
82 PieceLength: 256 << 10,
85 assert.EqualValues(b, 13410, t.numPieces())
88 r.SetReadahead(32 << 20)
91 assert.Len(b, t.readers, 7)
92 t.pendPieceRange(0, t.numPieces())
93 for i := 0; i < t.numPieces(); i += 3 {
94 t.completedPieces.Set(i, true)
96 for range iter.N(b.N) {
97 t.updateAllPiecePriorities()
101 // Check that a torrent containing zero-length file(s) will start, and that
102 // they're created in the filesystem. The client storage is assumed to be
103 // file-based on the native filesystem based.
104 func testEmptyFilesAndZeroPieceLength(t *testing.T, cfg *Config) {
105 cl, err := NewClient(cfg)
106 require.NoError(t, err)
108 ib, err := bencode.Marshal(metainfo.Info{
113 require.NoError(t, err)
114 fp := filepath.Join(cfg.DataDir, "empty")
116 assert.False(t, missinggo.FilePathExists(fp))
117 tt, err := cl.AddTorrent(&metainfo.MetaInfo{
120 require.NoError(t, err)
123 require.True(t, cl.WaitAll())
124 assert.True(t, missinggo.FilePathExists(fp))
127 func TestEmptyFilesAndZeroPieceLengthWithFileStorage(t *testing.T) {
128 cfg := TestingConfig()
129 ci := storage.NewFile(cfg.DataDir)
131 cfg.DefaultStorage = ci
132 testEmptyFilesAndZeroPieceLength(t, cfg)
135 func TestEmptyFilesAndZeroPieceLengthWithMMapStorage(t *testing.T) {
136 cfg := TestingConfig()
137 ci := storage.NewMMap(cfg.DataDir)
139 cfg.DefaultStorage = ci
140 testEmptyFilesAndZeroPieceLength(t, cfg)
143 func TestPieceHashFailed(t *testing.T) {
144 mi := testutil.GreetingMetaInfo()
147 infoHash: mi.HashInfoBytes(),
148 storageOpener: storage.NewClient(badStorage{}),
151 require.NoError(t, tt.setInfoBytes(mi.InfoBytes))
153 tt.pieces[1].dirtyChunks.AddRange(0, 3)
154 require.True(t, tt.pieceAllDirty(1))
155 tt.pieceHashed(1, false)
156 // Dirty chunks should be cleared so we can try again.
157 require.False(t, tt.pieceAllDirty(1))
161 // Check the behaviour of Torrent.Metainfo when metadata is not completed.
162 func TestTorrentMetainfoIncompleteMetadata(t *testing.T) {
163 cfg := TestingConfig()
165 cl, err := NewClient(cfg)
166 require.NoError(t, err)
169 mi := testutil.GreetingMetaInfo()
170 ih := mi.HashInfoBytes()
172 tt, _ := cl.AddTorrentInfoHash(ih)
173 assert.Nil(t, tt.Metainfo().InfoBytes)
174 assert.False(t, tt.haveAllMetadataPieces())
176 nc, err := net.Dial("tcp", cl.ListenAddr().String())
177 require.NoError(t, err)
180 var pex peerExtensionBytes
181 pex.SetBit(ExtensionBitExtended)
182 hr, ok, err := handshake(nc, &ih, [20]byte{}, pex)
183 require.NoError(t, err)
185 assert.True(t, hr.peerExtensionBytes.GetBit(ExtensionBitExtended))
186 assert.EqualValues(t, cl.PeerID(), hr.PeerID)
187 assert.Equal(t, ih, hr.Hash)
189 assert.EqualValues(t, 0, tt.metadataSize())
195 _, err = nc.Write(pp.Message{
197 ExtendedID: pp.HandshakeExtendedID,
198 ExtendedPayload: func() []byte {
199 d := map[string]interface{}{
200 "metadata_size": len(mi.InfoBytes),
202 b, err := bencode.Marshal(d)
208 }.MustMarshalBinary())
209 require.NoError(t, err)
211 tt.metadataChanged.Wait()
213 assert.Equal(t, make([]byte, len(mi.InfoBytes)), tt.metadataBytes)
214 assert.False(t, tt.haveAllMetadataPieces())
215 assert.Nil(t, tt.Metainfo().InfoBytes)