gorond

[btrtrc.git] / peer_protocol / pex_test.go

diff --git a/peer_protocol/pex_test.go b/peer_protocol/pex_test.go
index 7a493ead37fa7515a966c1ba60c9b16b02ea3b36..5e5e96c14a3f0854f8c366bb63f3dd3b3cb9352a 100644 (file)
--- a/peer_protocol/pex_test.go
+++ b/peer_protocol/pex_test.go
@@ -6,9 +6,9 @@ import (
        "net"
        "testing"
 
+       "github.com/anacrolix/dht/v2/krpc"
        "github.com/stretchr/testify/require"
 
-       "github.com/anacrolix/dht/v2/krpc"
        "github.com/anacrolix/torrent/bencode"
 )
 
@@ -29,132 +29,6 @@ func TestEmptyPexMsg(t *testing.T) {
        require.NoError(t, bencode.Unmarshal(b, &pm))
 }
 
-func TestPexAdd(t *testing.T) {
-       addrs4 := []krpc.NodeAddr{
-               krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 1), Port: 4747}, // 0
-               krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 1), Port: 4748}, // 1
-               krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 2), Port: 4747}, // 2
-               krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 2), Port: 4748}, // 3
-       }
-       addrs6 := []krpc.NodeAddr{
-               krpc.NodeAddr{IP: net.IPv6loopback, Port: 4747}, // 0
-               krpc.NodeAddr{IP: net.IPv6loopback, Port: 4748}, // 1
-               krpc.NodeAddr{IP: net.IPv6loopback, Port: 4749}, // 2
-               krpc.NodeAddr{IP: net.IPv6loopback, Port: 4750}, // 3
-       }
-       f := PexPrefersEncryption | PexOutgoingConn
-
-       t.Run("ipv4", func(t *testing.T) {
-               addrs := addrs4
-               m := new(PexMsg)
-               m.Drop(addrs[0])
-               m.Add(addrs[1], f)
-               for _, addr := range addrs {
-                       m.Add(addr, f)
-               }
-               targ := &PexMsg{
-                       Added: krpc.CompactIPv4NodeAddrs{
-                               addrs[1],
-                               addrs[2],
-                               addrs[3],
-                       },
-                       AddedFlags: []PexPeerFlags{f, f, f},
-                       Dropped:    krpc.CompactIPv4NodeAddrs{},
-               }
-               require.EqualValues(t, targ, m)
-       })
-       t.Run("ipv6", func(t *testing.T) {
-               addrs := addrs6
-               m := new(PexMsg)
-               m.Drop(addrs[0])
-               m.Add(addrs[1], f)
-               for _, addr := range addrs {
-                       m.Add(addr, f)
-               }
-               targ := &PexMsg{
-                       Added6: krpc.CompactIPv6NodeAddrs{
-                               addrs[1],
-                               addrs[2],
-                               addrs[3],
-                       },
-                       Added6Flags: []PexPeerFlags{f, f, f},
-                       Dropped6:    krpc.CompactIPv6NodeAddrs{},
-               }
-               require.EqualValues(t, targ, m)
-       })
-       t.Run("empty", func(t *testing.T) {
-               addr := krpc.NodeAddr{}
-               xm := new(PexMsg)
-               xm.Add(addr, f)
-               require.EqualValues(t, 0, len(xm.Added))
-               require.EqualValues(t, 0, len(xm.AddedFlags))
-               require.EqualValues(t, 0, len(xm.Added6))
-               require.EqualValues(t, 0, len(xm.Added6Flags))
-       })
-}
-
-func TestPexDrop(t *testing.T) {
-       addrs4 := []krpc.NodeAddr{
-               krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 1), Port: 4747}, // 0
-               krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 1), Port: 4748}, // 1
-               krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 2), Port: 4747}, // 2
-               krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 2), Port: 4748}, // 3
-       }
-       addrs6 := []krpc.NodeAddr{
-               krpc.NodeAddr{IP: net.IPv6loopback, Port: 4747}, // 0
-               krpc.NodeAddr{IP: net.IPv6loopback, Port: 4748}, // 1
-               krpc.NodeAddr{IP: net.IPv6loopback, Port: 4749}, // 2
-               krpc.NodeAddr{IP: net.IPv6loopback, Port: 4750}, // 3
-       }
-       f := PexPrefersEncryption | PexOutgoingConn
-
-       t.Run("ipv4", func(t *testing.T) {
-               addrs := addrs4
-               m := new(PexMsg)
-               m.Add(addrs[0], f)
-               m.Drop(addrs[1])
-               for _, addr := range addrs {
-                       m.Drop(addr)
-               }
-               targ := &PexMsg{
-                       AddedFlags: []PexPeerFlags{},
-                       Added:    krpc.CompactIPv4NodeAddrs{},
-                       Dropped: krpc.CompactIPv4NodeAddrs{
-                               addrs[1],
-                               addrs[2],
-                               addrs[3],
-                       },
-               }
-               require.EqualValues(t, targ, m)
-       })
-       t.Run("ipv6", func(t *testing.T) {
-               addrs := addrs6
-               m := new(PexMsg)
-               m.Add(addrs[0], f)
-               m.Drop(addrs[1])
-               for _, addr := range addrs {
-                       m.Drop(addr)
-               }
-               targ := &PexMsg{
-                       Added6Flags: []PexPeerFlags{},
-                       Added6:    krpc.CompactIPv6NodeAddrs{},
-                       Dropped6: krpc.CompactIPv6NodeAddrs{
-                               addrs[1],
-                               addrs[2],
-                               addrs[3],
-                       },
-               }
-               require.EqualValues(t, targ, m)
-       })
-       t.Run("empty", func(t *testing.T) {
-               addr := krpc.NodeAddr{}
-               xm := new(PexMsg)
-               xm.Drop(addr)
-               require.EqualValues(t, 0, len(xm.Dropped))
-               require.EqualValues(t, 0, len(xm.Dropped6))
-       })
-}
-
 func TestMarshalPexMessage(t *testing.T) {
        addr := krpc.NodeAddr{IP: net.IP{127, 0, 0, 1}, Port: 0x55aa}
        f := PexPrefersEncryption | PexOutgoingConn
@@ -162,19 +36,19 @@ func TestMarshalPexMessage(t *testing.T) {
        pm.Added = append(pm.Added, addr)
        pm.AddedFlags = append(pm.AddedFlags, f)
 
-       b, err := bencode.Marshal(pm)
+       _, err := bencode.Marshal(pm)
        require.NoError(t, err)
 
        pexExtendedId := ExtensionNumber(7)
        msg := pm.Message(pexExtendedId)
        expected := []byte("\x00\x00\x00\x4c\x14\x07d5:added6:\x7f\x00\x00\x01\x55\xaa7:added.f1:\x116:added60:8:added6.f0:7:dropped0:8:dropped60:e")
-       b, err = msg.MarshalBinary()
+       b, err := msg.MarshalBinary()
        require.NoError(t, err)
        require.EqualValues(t, b, expected)
 
        msg = Message{}
        dec := Decoder{
-               R:         bufio.NewReader(bytes.NewBuffer(b)),
+               R:         bufio.NewReader(bytes.NewReader(b)),
                MaxLength: 128,
        }
        pmOut := PexMsg{}