]> Sergey Matveev's repositories - btrtrc.git/blob - peer_protocol/protocol_test.go
go1.19 compat
[btrtrc.git] / peer_protocol / protocol_test.go
1 package peer_protocol
2
3 import (
4         "bufio"
5         "bytes"
6         "strings"
7         "testing"
8
9         "github.com/stretchr/testify/assert"
10 )
11
12 func TestBinaryReadSliceOfPointers(t *testing.T) {
13         var msg Message
14         r := bytes.NewBufferString("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00")
15         if r.Len() != 12 {
16                 t.Fatalf("expected 12 bytes left, but there %d", r.Len())
17         }
18         for _, data := range []*Integer{&msg.Index, &msg.Begin, &msg.Length} {
19                 err := data.Read(r)
20                 if err != nil {
21                         t.Fatal(err)
22                 }
23         }
24         if r.Len() != 0 {
25                 t.FailNow()
26         }
27 }
28
29 func TestConstants(t *testing.T) {
30         assert.EqualValues(t, 3, NotInterested)
31         assert.EqualValues(t, 14, HaveAll)
32 }
33
34 func TestBitfieldEncode(t *testing.T) {
35         bf := make([]bool, 37)
36         bf[2] = true
37         bf[7] = true
38         bf[32] = true
39         s := string(marshalBitfield(bf))
40         const expected = "\x21\x00\x00\x00\x80"
41         if s != expected {
42                 t.Fatalf("got %#v, expected %#v", s, expected)
43         }
44 }
45
46 func TestBitfieldUnmarshal(t *testing.T) {
47         bf := unmarshalBitfield([]byte("\x81\x06"))
48         expected := make([]bool, 16)
49         expected[0] = true
50         expected[7] = true
51         expected[13] = true
52         expected[14] = true
53         if len(bf) != len(expected) {
54                 t.FailNow()
55         }
56         for i := range expected {
57                 if bf[i] != expected[i] {
58                         t.FailNow()
59                 }
60         }
61 }
62
63 func TestHaveEncode(t *testing.T) {
64         actualBytes, err := Message{
65                 Type:  Have,
66                 Index: 42,
67         }.MarshalBinary()
68         if err != nil {
69                 t.Fatal(err)
70         }
71         actualString := string(actualBytes)
72         expected := "\x00\x00\x00\x05\x04\x00\x00\x00\x2a"
73         if actualString != expected {
74                 t.Fatalf("expected %#v, got %#v", expected, actualString)
75         }
76 }
77
78 func TestShortRead(t *testing.T) {
79         dec := Decoder{
80                 R:         bufio.NewReader(bytes.NewBufferString("\x00\x00\x00\x02\x00!")),
81                 MaxLength: 2,
82         }
83         msg := new(Message)
84         err := dec.Decode(msg)
85         if !strings.Contains(err.Error(), "1 unused bytes in message type Choke") {
86                 t.Fatal(err)
87         }
88 }
89
90 func TestUnexpectedEOF(t *testing.T) {
91         msg := new(Message)
92         for _, stream := range []string{
93                 "\x00\x00\x00",     // Header truncated.
94                 "\x00\x00\x00\x01", // Expecting 1 more byte.
95                 // Request with wrong length, and too short anyway.
96                 "\x00\x00\x00\x06\x06\x00\x00\x00\x00\x00",
97                 // Request truncated.
98                 "\x00\x00\x00\x0b\x06\x00\x00\x00\x00\x00",
99         } {
100                 dec := Decoder{
101                         R:         bufio.NewReader(bytes.NewBufferString(stream)),
102                         MaxLength: 42,
103                 }
104                 err := dec.Decode(msg)
105                 if err == nil {
106                         t.Fatalf("expected an error decoding %q", stream)
107                 }
108         }
109 }
110
111 func TestMarshalKeepalive(t *testing.T) {
112         b, err := (Message{
113                 Keepalive: true,
114         }).MarshalBinary()
115         if err != nil {
116                 t.Fatalf("error marshalling keepalive: %s", err)
117         }
118         bs := string(b)
119         const expected = "\x00\x00\x00\x00"
120         if bs != expected {
121                 t.Fatalf("marshalled keepalive is %q, expected %q", bs, expected)
122         }
123 }
124
125 func TestMarshalPortMsg(t *testing.T) {
126         b, err := (Message{
127                 Type: Port,
128                 Port: 0xaabb,
129         }).MarshalBinary()
130         if err != nil {
131                 t.Fatal(err)
132         }
133         if string(b) != "\x00\x00\x00\x03\x09\xaa\xbb" {
134                 t.FailNow()
135         }
136 }
137
138 func TestUnmarshalPortMsg(t *testing.T) {
139         var m Message
140         d := Decoder{
141                 R:         bufio.NewReader(bytes.NewBufferString("\x00\x00\x00\x03\x09\xaa\xbb")),
142                 MaxLength: 8,
143         }
144         err := d.Decode(&m)
145         if err != nil {
146                 t.Fatal(err)
147         }
148         if m.Type != Port {
149                 t.FailNow()
150         }
151         if m.Port != 0xaabb {
152                 t.FailNow()
153         }
154 }