Drop support for go 1.20

[btrtrc.git] / peerconn_test.go

diff --git a/peerconn_test.go b/peerconn_test.go
index 42f8fe273131b29dda29d4d7e666975d2858e023..e294b6b620590de33886514facd5bfd46cae9bc6 100644 (file)
--- a/peerconn_test.go
+++ b/peerconn_test.go
@@ -9,11 +9,10 @@ import (
        "sync"
        "testing"
 
-       "golang.org/x/time/rate"
-
        "github.com/frankban/quicktest"
        qt "github.com/frankban/quicktest"
        "github.com/stretchr/testify/require"
+       "golang.org/x/time/rate"
 
        "github.com/anacrolix/torrent/metainfo"
        pp "github.com/anacrolix/torrent/peer_protocol"
@@ -182,6 +181,7 @@ func TestConnPexPeerFlags(t *testing.T) {
 }
 
 func TestConnPexEvent(t *testing.T) {
+       c := qt.New(t)
        var (
                udpAddr     = &net.UDPAddr{IP: net.IPv6loopback, Port: 4848}
                tcpAddr     = &net.TCPAddr{IP: net.IPv6loopback, Port: 4848}
@@ -196,27 +196,39 @@ func TestConnPexEvent(t *testing.T) {
                {
                        pexAdd,
                        &PeerConn{Peer: Peer{RemoteAddr: udpAddr, Network: udpAddr.Network()}},
-                       pexEvent{pexAdd, udpAddr, pp.PexSupportsUtp, nil},
+                       pexEvent{pexAdd, udpAddr.AddrPort(), pp.PexSupportsUtp, nil},
                },
                {
                        pexDrop,
-                       &PeerConn{Peer: Peer{RemoteAddr: tcpAddr, Network: tcpAddr.Network(), outgoing: true, PeerListenPort: dialTcpAddr.Port}},
-                       pexEvent{pexDrop, tcpAddr, pp.PexOutgoingConn, nil},
+                       &PeerConn{
+                               Peer:           Peer{RemoteAddr: tcpAddr, Network: tcpAddr.Network(), outgoing: true},
+                               PeerListenPort: dialTcpAddr.Port,
+                       },
+                       pexEvent{pexDrop, tcpAddr.AddrPort(), pp.PexOutgoingConn, nil},
                },
                {
                        pexAdd,
-                       &PeerConn{Peer: Peer{RemoteAddr: tcpAddr, Network: tcpAddr.Network(), PeerListenPort: dialTcpAddr.Port}},
-                       pexEvent{pexAdd, dialTcpAddr, 0, nil},
+                       &PeerConn{
+                               Peer:           Peer{RemoteAddr: tcpAddr, Network: tcpAddr.Network()},
+                               PeerListenPort: dialTcpAddr.Port,
+                       },
+                       pexEvent{pexAdd, dialTcpAddr.AddrPort(), 0, nil},
                },
                {
                        pexDrop,
-                       &PeerConn{Peer: Peer{RemoteAddr: udpAddr, Network: udpAddr.Network(), PeerListenPort: dialUdpAddr.Port}},
-                       pexEvent{pexDrop, dialUdpAddr, pp.PexSupportsUtp, nil},
+                       &PeerConn{
+                               Peer:           Peer{RemoteAddr: udpAddr, Network: udpAddr.Network()},
+                               PeerListenPort: dialUdpAddr.Port,
+                       },
+                       pexEvent{pexDrop, dialUdpAddr.AddrPort(), pp.PexSupportsUtp, nil},
                },
        }
        for i, tc := range testcases {
-               e := tc.c.pexEvent(tc.t)
-               require.EqualValues(t, tc.e, e, i)
+               c.Run(fmt.Sprintf("%v", i), func(c *qt.C) {
+                       e, err := tc.c.pexEvent(tc.t)
+                       c.Assert(err, qt.IsNil)
+                       c.Check(e, qt.Equals, tc.e)
+               })
        }
 }
 
@@ -257,14 +269,17 @@ func TestApplyRequestStateWriteBufferConstraints(t *testing.T) {
        c.Logf("max local to remote requests: %v", maxLocalToRemoteRequests)
 }
 
-func peerConnForPreferredNetworkDirection(localPeerId, remotePeerId int, outgoing, utp, ipv6 bool) *PeerConn {
+func peerConnForPreferredNetworkDirection(
+       localPeerId, remotePeerId int,
+       outgoing, utp, ipv6 bool,
+) *PeerConn {
        pc := PeerConn{}
        pc.outgoing = outgoing
        if utp {
                pc.Network = "udp"
        }
        if ipv6 {
-               pc.RemoteAddr = &net.TCPAddr{IP: net.ParseIP(fmt.Sprintf("::420"))}
+               pc.RemoteAddr = &net.TCPAddr{IP: net.ParseIP("::420")}
        } else {
                pc.RemoteAddr = &net.TCPAddr{IP: net.IPv4(1, 2, 3, 4)}
        }
@@ -278,16 +293,37 @@ func peerConnForPreferredNetworkDirection(localPeerId, remotePeerId int, outgoin
 func TestPreferredNetworkDirection(t *testing.T) {
        pc := peerConnForPreferredNetworkDirection
        c := qt.New(t)
-       // Prefer outgoing to higher peer ID
-       c.Assert(pc(1, 2, true, false, false).hasPreferredNetworkOver(pc(1, 2, false, false, false)), qt.IsTrue)
-       c.Assert(pc(1, 2, false, false, false).hasPreferredNetworkOver(pc(1, 2, true, false, false)), qt.IsFalse)
-       c.Assert(pc(2, 1, false, false, false).hasPreferredNetworkOver(pc(2, 1, true, false, false)), qt.IsTrue)
+
+       // Prefer outgoing to lower peer ID
+
+       c.Check(
+               pc(1, 2, true, false, false).hasPreferredNetworkOver(pc(1, 2, false, false, false)),
+               qt.IsFalse,
+       )
+       c.Check(
+               pc(1, 2, false, false, false).hasPreferredNetworkOver(pc(1, 2, true, false, false)),
+               qt.IsTrue,
+       )
+       c.Check(
+               pc(2, 1, false, false, false).hasPreferredNetworkOver(pc(2, 1, true, false, false)),
+               qt.IsFalse,
+       )
+
        // Don't prefer uTP
-       c.Assert(pc(1, 2, false, true, false).hasPreferredNetworkOver(pc(1, 2, false, false, false)), qt.IsFalse)
+       c.Check(
+               pc(1, 2, false, true, false).hasPreferredNetworkOver(pc(1, 2, false, false, false)),
+               qt.IsFalse,
+       )
        // Prefer IPv6
-       c.Assert(pc(1, 2, false, false, false).hasPreferredNetworkOver(pc(1, 2, false, false, true)), qt.IsFalse)
+       c.Check(
+               pc(1, 2, false, false, false).hasPreferredNetworkOver(pc(1, 2, false, false, true)),
+               qt.IsFalse,
+       )
        // No difference
-       c.Assert(pc(1, 2, false, false, false).hasPreferredNetworkOver(pc(1, 2, false, false, false)), qt.IsFalse)
+       c.Check(
+               pc(1, 2, false, false, false).hasPreferredNetworkOver(pc(1, 2, false, false, false)),
+               qt.IsFalse,
+       )
 }
 
 func TestReceiveLargeRequest(t *testing.T) {