tracker/udp/udp_test.go

   1 package udp
   2
   3 import (
   4         "bytes"
   5         "encoding/binary"
   6         "io"
   7         "net"
   8         "testing"
   9
  10         "github.com/anacrolix/dht/v2/krpc"
  11         qt "github.com/frankban/quicktest"
  12         "github.com/stretchr/testify/require"
  13 )
  14
  15 // Ensure net.IPs are stored big-endian, to match the way they're read from
  16 // the wire.
  17 func TestNetIPv4Bytes(t *testing.T) {
  18         ip := net.IP([]byte{127, 0, 0, 1})
  19         if ip.String() != "127.0.0.1" {
  20                 t.FailNow()
  21         }
  22         if string(ip) != "\x7f\x00\x00\x01" {
  23                 t.Fatal([]byte(ip))
  24         }
  25 }
  26
  27 func TestMarshalAnnounceResponse(t *testing.T) {
  28         peers := krpc.CompactIPv4NodeAddrs{
  29                 {[]byte{127, 0, 0, 1}, 2},
  30                 {[]byte{255, 0, 0, 3}, 4},
  31         }
  32         b, err := peers.MarshalBinary()
  33         require.NoError(t, err)
  34         require.EqualValues(t,
  35                 "\x7f\x00\x00\x01\x00\x02\xff\x00\x00\x03\x00\x04",
  36                 b)
  37         require.EqualValues(t, 12, binary.Size(AnnounceResponseHeader{}))
  38 }
  39
  40 // Failure to write an entire packet to UDP is expected to given an error.
  41 func TestLongWriteUDP(t *testing.T) {
  42         t.Parallel()
  43         l, err := net.ListenUDP("udp4", nil)
  44         require.NoError(t, err)
  45         defer l.Close()
  46         c, err := net.DialUDP("udp", nil, l.LocalAddr().(*net.UDPAddr))
  47         if err != nil {
  48                 t.Fatal(err)
  49         }
  50         defer c.Close()
  51         for msgLen := 1; ; msgLen *= 2 {
  52                 n, err := c.Write(make([]byte, msgLen))
  53                 if err != nil {
  54                         require.Contains(t, err.Error(), "message too long")
  55                         return
  56                 }
  57                 if n < msgLen {
  58                         t.FailNow()
  59                 }
  60         }
  61 }
  62
  63 func TestShortBinaryRead(t *testing.T) {
  64         var data ResponseHeader
  65         err := binary.Read(bytes.NewBufferString("\x00\x00\x00\x01"), binary.BigEndian, &data)
  66         if err != io.ErrUnexpectedEOF {
  67                 t.FailNow()
  68         }
  69 }
  70
  71 func TestConvertInt16ToInt(t *testing.T) {
  72         i := 50000
  73         if int(uint16(int16(i))) != 50000 {
  74                 t.FailNow()
  75         }
  76 }
  77
  78 func TestConnClientLogDispatchUnknownTransactionId(t *testing.T) {
  79         const network = "udp"
  80         cc, err := NewConnClient(NewConnClientOpts{
  81                 Network: network,
  82         })
  83         c := qt.New(t)
  84         c.Assert(err, qt.IsNil)
  85         defer cc.Close()
  86         pc, err := net.ListenPacket(network, ":0")
  87         c.Assert(err, qt.IsNil)
  88         defer pc.Close()
  89         ccAddr := *cc.LocalAddr().(*net.UDPAddr)
  90         ccAddr.IP = net.IPv6loopback
  91         _, err = pc.WriteTo(make([]byte, 30), &ccAddr)
  92         c.Assert(err, qt.IsNil)
  93 }