Drop support for go 1.20

[btrtrc.git] / torrent_test.go

diff --git a/torrent_test.go b/torrent_test.go
index b40650391d2e7c01e0636ed959797f5be349b620..808947e974a23fe9df13e8fb5714eac781445305 100644 (file)
--- a/torrent_test.go
+++ b/torrent_test.go
@@ -6,10 +6,14 @@ import (
        "net"
        "os"
        "path/filepath"
+       "sync"
        "testing"
 
-       "github.com/anacrolix/missinggo"
-       "github.com/bradfitz/iter"
+       g "github.com/anacrolix/generics"
+       "github.com/anacrolix/log"
+       "github.com/anacrolix/missinggo/v2"
+       "github.com/anacrolix/missinggo/v2/bitmap"
+       qt "github.com/frankban/quicktest"
        "github.com/stretchr/testify/assert"
        "github.com/stretchr/testify/require"
 
@@ -81,7 +85,7 @@ func BenchmarkUpdatePiecePriorities(b *testing.B) {
                numPieces   = 13410
                pieceLength = 256 << 10
        )
-       cl := &Client{config: TestingConfig()}
+       cl := &Client{config: TestingConfig(b)}
        cl.initLogger()
        t := cl.newTorrent(metainfo.Hash{}, nil)
        require.NoError(b, t.setInfo(&metainfo.Info{
@@ -89,19 +93,20 @@ func BenchmarkUpdatePiecePriorities(b *testing.B) {
                PieceLength: pieceLength,
                Length:      pieceLength * numPieces,
        }))
+       t.onSetInfo()
        assert.EqualValues(b, 13410, t.numPieces())
-       for range iter.N(7) {
+       for i := 0; i < 7; i += 1 {
                r := t.NewReader()
                r.SetReadahead(32 << 20)
                r.Seek(3500000, io.SeekStart)
        }
        assert.Len(b, t.readers, 7)
-       for i := 0; i < int(t.numPieces()); i += 3 {
-               t._completedPieces.Set(i, true)
+       for i := 0; i < t.numPieces(); i += 3 {
+               t._completedPieces.Add(bitmap.BitIndex(i))
        }
        t.DownloadPieces(0, t.numPieces())
-       for range iter.N(b.N) {
-               t.updateAllPiecePriorities()
+       for i := 0; i < b.N; i += 1 {
+               t.updateAllPiecePriorities("")
        }
 }
 
@@ -128,35 +133,28 @@ func testEmptyFilesAndZeroPieceLength(t *testing.T, cfg *ClientConfig) {
        defer tt.Drop()
        tt.DownloadAll()
        require.True(t, cl.WaitAll())
+       assert.True(t, tt.Complete.Bool())
        assert.True(t, missinggo.FilePathExists(fp))
 }
 
 func TestEmptyFilesAndZeroPieceLengthWithFileStorage(t *testing.T) {
-       cfg := TestingConfig()
+       cfg := TestingConfig(t)
        ci := storage.NewFile(cfg.DataDir)
        defer ci.Close()
        cfg.DefaultStorage = ci
        testEmptyFilesAndZeroPieceLength(t, cfg)
 }
 
-func TestEmptyFilesAndZeroPieceLengthWithMMapStorage(t *testing.T) {
-       cfg := TestingConfig()
-       ci := storage.NewMMap(cfg.DataDir)
-       defer ci.Close()
-       cfg.DefaultStorage = ci
-       testEmptyFilesAndZeroPieceLength(t, cfg)
-}
-
 func TestPieceHashFailed(t *testing.T) {
        mi := testutil.GreetingMetaInfo()
-       cl := new(Client)
-       cl.config = TestingConfig()
-       cl.initLogger()
+       cl := newTestingClient(t)
        tt := cl.newTorrent(mi.HashInfoBytes(), badStorage{})
        tt.setChunkSize(2)
-       require.NoError(t, tt.setInfoBytes(mi.InfoBytes))
+       require.NoError(t, tt.setInfoBytesLocked(mi.InfoBytes))
        tt.cl.lock()
-       tt.pieces[1]._dirtyChunks.AddRange(0, 3)
+       tt.dirtyChunks.AddRange(
+               uint64(tt.pieceRequestIndexOffset(1)),
+               uint64(tt.pieceRequestIndexOffset(1)+3))
        require.True(t, tt.pieceAllDirty(1))
        tt.pieceHashed(1, false, nil)
        // Dirty chunks should be cleared so we can try again.
@@ -166,8 +164,10 @@ func TestPieceHashFailed(t *testing.T) {
 
 // Check the behaviour of Torrent.Metainfo when metadata is not completed.
 func TestTorrentMetainfoIncompleteMetadata(t *testing.T) {
-       cfg := TestingConfig()
+       cfg := TestingConfig(t)
        cfg.Debug = true
+       // Disable this just because we manually initiate a connection without it.
+       cfg.MinPeerExtensions.SetBit(pp.ExtensionBitFast, false)
        cl, err := NewClient(cfg)
        require.NoError(t, err)
        defer cl.Close()
@@ -184,10 +184,10 @@ func TestTorrentMetainfoIncompleteMetadata(t *testing.T) {
        defer nc.Close()
 
        var pex PeerExtensionBits
-       pex.SetBit(pp.ExtensionBitExtended, true)
+       pex.SetBit(pp.ExtensionBitLtep, true)
        hr, err := pp.Handshake(nc, &ih, [20]byte{}, pex)
        require.NoError(t, err)
-       assert.True(t, hr.PeerExtensionBits.GetBit(pp.ExtensionBitExtended))
+       assert.True(t, hr.PeerExtensionBits.GetBit(pp.ExtensionBitLtep))
        assert.EqualValues(t, cl.PeerID(), hr.PeerID)
        assert.EqualValues(t, ih, hr.Hash)
 
@@ -219,3 +219,35 @@ func TestTorrentMetainfoIncompleteMetadata(t *testing.T) {
        assert.False(t, tt.haveAllMetadataPieces())
        assert.Nil(t, tt.Metainfo().InfoBytes)
 }
+
+func TestRelativeAvailabilityHaveNone(t *testing.T) {
+       c := qt.New(t)
+       var err error
+       cl := Client{
+               config: TestingConfig(t),
+       }
+       tt := Torrent{
+               cl:           &cl,
+               logger:       log.Default,
+               gotMetainfoC: make(chan struct{}),
+       }
+       tt.setChunkSize(2)
+       g.MakeMapIfNil(&tt.conns)
+       pc := PeerConn{}
+       pc.t = &tt
+       pc.peerImpl = &pc
+       pc.initRequestState()
+       g.InitNew(&pc.callbacks)
+       tt.conns[&pc] = struct{}{}
+       err = pc.peerSentHave(0)
+       c.Assert(err, qt.IsNil)
+       info := testutil.Greeting.Info(5)
+       err = tt.setInfo(&info)
+       c.Assert(err, qt.IsNil)
+       tt.onSetInfo()
+       err = pc.peerSentHaveNone()
+       c.Assert(err, qt.IsNil)
+       var wg sync.WaitGroup
+       tt.close(&wg)
+       tt.assertAllPiecesRelativeAvailabilityZero()
+}