peer_protocol/protocol_test.go

   1 package peer_protocol
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "io"
   7         "strings"
   8         "testing"
   9 )
  10
  11 func TestBinaryReadSliceOfPointers(t *testing.T) {
  12         var msg Message
  13         r := bytes.NewBufferString("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00")
  14         if r.Len() != 12 {
  15                 t.Fatalf("expected 12 bytes left, but there %d", r.Len())
  16         }
  17         for _, data := range []*Integer{&msg.Index, &msg.Begin, &msg.Length} {
  18                 err := data.Read(r)
  19                 if err != nil {
  20                         t.Fatal(err)
  21                 }
  22         }
  23         if r.Len() != 0 {
  24                 t.FailNow()
  25         }
  26 }
  27
  28 func TestConstants(t *testing.T) {
  29         // check that iota works as expected in the const block
  30         if NotInterested != 3 {
  31                 t.FailNow()
  32         }
  33 }
  34
  35 func TestBitfieldEncode(t *testing.T) {
  36         bf := make([]bool, 37)
  37         bf[2] = true
  38         bf[7] = true
  39         bf[32] = true
  40         s := string(marshalBitfield(bf))
  41         const expected = "\x21\x00\x00\x00\x80"
  42         if s != expected {
  43                 t.Fatalf("got %#v, expected %#v", s, expected)
  44         }
  45 }
  46
  47 func TestBitfieldUnmarshal(t *testing.T) {
  48         bf := unmarshalBitfield([]byte("\x81\x06"))
  49         expected := make([]bool, 16)
  50         expected[0] = true
  51         expected[7] = true
  52         expected[13] = true
  53         expected[14] = true
  54         if len(bf) != len(expected) {
  55                 t.FailNow()
  56         }
  57         for i := range expected {
  58                 if bf[i] != expected[i] {
  59                         t.FailNow()
  60                 }
  61         }
  62 }
  63
  64 func TestHaveEncode(t *testing.T) {
  65         actualBytes, err := Message{
  66                 Type:  Have,
  67                 Index: 42,
  68         }.MarshalBinary()
  69         if err != nil {
  70                 t.Fatal(err)
  71         }
  72         actualString := string(actualBytes)
  73         expected := "\x00\x00\x00\x05\x04\x00\x00\x00\x2a"
  74         if actualString != expected {
  75                 t.Fatalf("expected %#v, got %#v", expected, actualString)
  76         }
  77 }
  78
  79 func TestShortRead(t *testing.T) {
  80         dec := Decoder{
  81                 R:         bufio.NewReader(bytes.NewBufferString("\x00\x00\x00\x02\x00!")),
  82                 MaxLength: 2,
  83         }
  84         msg := new(Message)
  85         err := dec.Decode(msg)
  86         if !strings.Contains(err.Error(), "short read") {
  87                 t.Fatal(err)
  88         }
  89 }
  90
  91 func TestUnexpectedEOF(t *testing.T) {
  92         msg := new(Message)
  93         for _, stream := range []string{
  94                 "\x00\x00\x00",     // Header truncated.
  95                 "\x00\x00\x00\x01", // Expecting 1 more byte.
  96                 // Request with wrong length, and too short anyway.
  97                 "\x00\x00\x00\x06\x06\x00\x00\x00\x00\x00",
  98                 // Request truncated.
  99                 "\x00\x00\x00\x0b\x06\x00\x00\x00\x00\x00",
 100         } {
 101                 dec := Decoder{
 102                         R:         bufio.NewReader(bytes.NewBufferString(stream)),
 103                         MaxLength: 42,
 104                 }
 105                 err := dec.Decode(msg)
 106                 if err != io.ErrUnexpectedEOF {
 107                         t.Fatalf("expected ErrUnexpectedEOF decoding %q, got %s", stream, err)
 108                 }
 109         }
 110 }
 111
 112 func TestMarshalKeepalive(t *testing.T) {
 113         b, err := (Message{
 114                 Keepalive: true,
 115         }).MarshalBinary()
 116         if err != nil {
 117                 t.Fatalf("error marshalling keepalive: %s", err)
 118         }
 119         bs := string(b)
 120         const expected = "\x00\x00\x00\x00"
 121         if bs != expected {
 122                 t.Fatalf("marshalled keepalive is %q, expected %q", bs, expected)
 123         }
 124 }