cmd/btrtrc client

[btrtrc.git] / peerconn_test.go

diff --git a/peerconn_test.go b/peerconn_test.go
index 8a640544fc8ca3788f7112d8101c33d4a618a872..e294b6b620590de33886514facd5bfd46cae9bc6 100644 (file)
--- a/peerconn_test.go
+++ b/peerconn_test.go
@@ -4,10 +4,8 @@ import (
        "encoding/binary"
        "errors"
        "fmt"
-       "golang.org/x/sync/errgroup"
        "io"
        "net"
-       "net/netip"
        "sync"
        "testing"
 
@@ -27,11 +25,11 @@ func TestSendBitfieldThenHave(t *testing.T) {
        var cl Client
        cl.init(TestingConfig(t))
        cl.initLogger()
-       qtc := qt.New(t)
        c := cl.newConnection(nil, newConnectionOpts{network: "io.Pipe"})
        c.setTorrent(cl.newTorrent(metainfo.Hash{}, nil))
-       err := c.t.setInfo(&metainfo.Info{Pieces: make([]byte, metainfo.HashSize*3)})
-       qtc.Assert(err, qt.IsNil)
+       if err := c.t.setInfo(&metainfo.Info{Pieces: make([]byte, metainfo.HashSize*3)}); err != nil {
+               t.Log(err)
+       }
        r, w := io.Pipe()
        // c.r = r
        c.w = w
@@ -109,32 +107,29 @@ func BenchmarkConnectionMainReadLoop(b *testing.B) {
        t.onSetInfo()
        t._pendingPieces.Add(0)
        r, w := net.Pipe()
-       c.Logf("pipe reader remote addr: %v", r.RemoteAddr())
        cn := cl.newConnection(r, newConnectionOpts{
-               outgoing: true,
-               // TODO: This is a hack to give the pipe a bannable remote address.
-               remoteAddr: netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 2, 3, 4}), 1234),
+               outgoing:   true,
+               remoteAddr: r.RemoteAddr(),
                network:    r.RemoteAddr().Network(),
                connString: regularNetConnPeerConnConnString(r),
        })
-       c.Assert(cn.bannableAddr.Ok, qt.IsTrue)
        cn.setTorrent(t)
+       mrlErrChan := make(chan error)
        msg := pp.Message{
                Type:  pp.Piece,
                Piece: make([]byte, defaultChunkSize),
        }
-       var errGroup errgroup.Group
-       errGroup.Go(func() error {
+       go func() {
                cl.lock()
                err := cn.mainReadLoop()
-               if errors.Is(err, io.EOF) {
-                       err = nil
+               if err != nil {
+                       mrlErrChan <- err
                }
-               return err
-       })
+               close(mrlErrChan)
+       }()
        wb := msg.MustMarshalBinary()
        b.SetBytes(int64(len(msg.Piece)))
-       errGroup.Go(func() error {
+       go func() {
                ts.writeSem.Lock()
                for i := 0; i < b.N; i += 1 {
                        cl.lock()
@@ -148,19 +143,17 @@ func BenchmarkConnectionMainReadLoop(b *testing.B) {
                        n, err := w.Write(wb)
                        require.NoError(b, err)
                        require.EqualValues(b, len(wb), n)
-                       // This is unlocked by a successful write to storage. So this unblocks when that is
-                       // done.
                        ts.writeSem.Lock()
                }
                if err := w.Close(); err != nil {
                        panic(err)
                }
-               return nil
-       })
-       err := errGroup.Wait()
-       c.Assert(err, qt.IsNil)
+       }()
+       mrlErr := <-mrlErrChan
+       if mrlErr != nil && !errors.Is(mrlErr, io.EOF) {
+               c.Fatal(mrlErr)
+       }
        c.Assert(cn._stats.ChunksReadUseful.Int64(), quicktest.Equals, int64(b.N))
-       c.Assert(t.smartBanCache.HasBlocks(), qt.IsTrue)
 }
 
 func TestConnPexPeerFlags(t *testing.T) {