github.com/anacrolix/torrent@v1.61.0/peer_protocol/protocol_test.go (about)

     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  }