bencode/decode_test.go

   1 package bencode
   2
   3 import (
   4         "bytes"
   5         "fmt"
   6         "io"
   7         "math/big"
   8         "reflect"
   9         "testing"
  10
  11         qt "github.com/frankban/quicktest"
  12         "github.com/stretchr/testify/assert"
  13         "github.com/stretchr/testify/require"
  14 )
  15
  16 type random_decode_test struct {
  17         data     string
  18         expected interface{}
  19 }
  20
  21 var random_decode_tests = []random_decode_test{
  22         {"i57e", int64(57)},
  23         {"i-9223372036854775808e", int64(-9223372036854775808)},
  24         {"5:hello", "hello"},
  25         {"29:unicode test проверка", "unicode test проверка"},
  26         {"d1:ai5e1:b5:helloe", map[string]interface{}{"a": int64(5), "b": "hello"}},
  27         {
  28                 "li5ei10ei15ei20e7:bencodee",
  29                 []interface{}{int64(5), int64(10), int64(15), int64(20), "bencode"},
  30         },
  31         {"ldedee", []interface{}{map[string]interface{}{}, map[string]interface{}{}}},
  32         {"le", []interface{}{}},
  33         {"i604919719469385652980544193299329427705624352086e", func() *big.Int {
  34                 ret, _ := big.NewInt(-1).SetString("604919719469385652980544193299329427705624352086", 10)
  35                 return ret
  36         }()},
  37         {"d1:rd6:\xd4/\xe2F\x00\x01i42ee1:t3:\x9a\x87\x011:v4:TR%=1:y1:re", map[string]interface{}{
  38                 "r": map[string]interface{}{"\xd4/\xe2F\x00\x01": int64(42)},
  39                 "t": "\x9a\x87\x01",
  40                 "v": "TR%=",
  41                 "y": "r",
  42         }},
  43         {"d0:i420ee", map[string]interface{}{"": int64(420)}},
  44 }
  45
  46 func TestRandomDecode(t *testing.T) {
  47         for _, test := range random_decode_tests {
  48                 var value interface{}
  49                 err := Unmarshal([]byte(test.data), &value)
  50                 if err != nil {
  51                         t.Error(err, test.data)
  52                         continue
  53                 }
  54                 assert.EqualValues(t, test.expected, value)
  55         }
  56 }
  57
  58 func TestLoneE(t *testing.T) {
  59         var v int
  60         err := Unmarshal([]byte("e"), &v)
  61         se := err.(*SyntaxError)
  62         require.EqualValues(t, 0, se.Offset)
  63 }
  64
  65 func TestDecoderConsecutive(t *testing.T) {
  66         d := NewDecoder(bytes.NewReader([]byte("i1ei2e")))
  67         var i int
  68         err := d.Decode(&i)
  69         require.NoError(t, err)
  70         require.EqualValues(t, 1, i)
  71         err = d.Decode(&i)
  72         require.NoError(t, err)
  73         require.EqualValues(t, 2, i)
  74         err = d.Decode(&i)
  75         require.Equal(t, io.EOF, err)
  76 }
  77
  78 func TestDecoderConsecutiveDicts(t *testing.T) {
  79         bb := bytes.NewBufferString("d4:herp4:derped3:wat1:ke17:oh baby a triple!")
  80
  81         d := NewDecoder(bb)
  82         assert.EqualValues(t, "d4:herp4:derped3:wat1:ke17:oh baby a triple!", bb.Bytes())
  83         assert.EqualValues(t, 0, d.Offset)
  84
  85         var m map[string]interface{}
  86
  87         require.NoError(t, d.Decode(&m))
  88         assert.Len(t, m, 1)
  89         assert.Equal(t, "derp", m["herp"])
  90         assert.Equal(t, "d3:wat1:ke17:oh baby a triple!", bb.String())
  91         assert.EqualValues(t, 14, d.Offset)
  92
  93         require.NoError(t, d.Decode(&m))
  94         assert.Equal(t, "k", m["wat"])
  95         assert.Equal(t, "17:oh baby a triple!", bb.String())
  96         assert.EqualValues(t, 24, d.Offset)
  97
  98         var s string
  99         require.NoError(t, d.Decode(&s))
 100         assert.Equal(t, "oh baby a triple!", s)
 101         assert.EqualValues(t, 44, d.Offset)
 102 }
 103
 104 func check_error(t *testing.T, err error) {
 105         if err != nil {
 106                 t.Error(err)
 107         }
 108 }
 109
 110 func assert_equal(t *testing.T, x, y interface{}) {
 111         if !reflect.DeepEqual(x, y) {
 112                 t.Errorf("got: %v (%T), expected: %v (%T)\n", x, x, y, y)
 113         }
 114 }
 115
 116 type unmarshalerInt struct {
 117         x int
 118 }
 119
 120 func (me *unmarshalerInt) UnmarshalBencode(data []byte) error {
 121         return Unmarshal(data, &me.x)
 122 }
 123
 124 type unmarshalerString struct {
 125         x string
 126 }
 127
 128 func (me *unmarshalerString) UnmarshalBencode(data []byte) error {
 129         me.x = string(data)
 130         return nil
 131 }
 132
 133 func TestUnmarshalerBencode(t *testing.T) {
 134         var i unmarshalerInt
 135         var ss []unmarshalerString
 136         check_error(t, Unmarshal([]byte("i71e"), &i))
 137         assert_equal(t, i.x, 71)
 138         check_error(t, Unmarshal([]byte("l5:hello5:fruit3:waye"), &ss))
 139         assert_equal(t, ss[0].x, "5:hello")
 140         assert_equal(t, ss[1].x, "5:fruit")
 141         assert_equal(t, ss[2].x, "3:way")
 142 }
 143
 144 func TestIgnoreUnmarshalTypeError(t *testing.T) {
 145         s := struct {
 146                 Ignore int `bencode:",ignore_unmarshal_type_error"`
 147                 Normal int
 148         }{}
 149         require.Error(t, Unmarshal([]byte("d6:Normal5:helloe"), &s))
 150         assert.NoError(t, Unmarshal([]byte("d6:Ignore5:helloe"), &s))
 151         qt.Assert(t, Unmarshal([]byte("d6:Ignorei42ee"), &s), qt.IsNil)
 152         assert.EqualValues(t, 42, s.Ignore)
 153 }
 154
 155 // Test unmarshalling []byte into something that has the same kind but
 156 // different type.
 157 func TestDecodeCustomSlice(t *testing.T) {
 158         type flag byte
 159         var fs3, fs2 []flag
 160         // We do a longer slice then a shorter slice to see if the buffers are
 161         // shared.
 162         d := NewDecoder(bytes.NewBufferString("3:\x01\x10\xff2:\x04\x0f"))
 163         require.NoError(t, d.Decode(&fs3))
 164         require.NoError(t, d.Decode(&fs2))
 165         assert.EqualValues(t, []flag{1, 16, 255}, fs3)
 166         assert.EqualValues(t, []flag{4, 15}, fs2)
 167 }
 168
 169 func TestUnmarshalUnusedBytes(t *testing.T) {
 170         var i int
 171         require.EqualValues(t, ErrUnusedTrailingBytes{1}, Unmarshal([]byte("i42ee"), &i))
 172         assert.EqualValues(t, 42, i)
 173 }
 174
 175 func TestUnmarshalByteArray(t *testing.T) {
 176         var ba [2]byte
 177         assert.NoError(t, Unmarshal([]byte("2:hi"), &ba))
 178         assert.EqualValues(t, "hi", ba[:])
 179 }
 180
 181 func TestDecodeDictIntoUnsupported(t *testing.T) {
 182         // Any type that a dict shouldn't be unmarshallable into.
 183         var i int
 184         c := qt.New(t)
 185         err := Unmarshal([]byte("d1:a1:be"), &i)
 186         t.Log(err)
 187         c.Check(err, qt.Not(qt.IsNil))
 188 }
 189
 190 func TestUnmarshalDictKeyNotString(t *testing.T) {
 191         // Any type that a dict shouldn't be unmarshallable into.
 192         var i int
 193         c := qt.New(t)
 194         err := Unmarshal([]byte("di42e3:yese"), &i)
 195         t.Log(err)
 196         c.Check(err, qt.Not(qt.IsNil))
 197 }
 198
 199 type arbitraryReader struct{}
 200
 201 func (arbitraryReader) Read(b []byte) (int, error) {
 202         return len(b), nil
 203 }
 204
 205 func decodeHugeString(t *testing.T, strLen int64, header, tail string, v interface{}, maxStrLen MaxStrLen) error {
 206         r, w := io.Pipe()
 207         go func() {
 208                 fmt.Fprintf(w, header, strLen)
 209                 io.CopyN(w, arbitraryReader{}, strLen)
 210                 w.Write([]byte(tail))
 211                 w.Close()
 212         }()
 213         d := NewDecoder(r)
 214         d.MaxStrLen = maxStrLen
 215         return d.Decode(v)
 216 }
 217
 218 // Ensure that bencode strings in various places obey the Decoder.MaxStrLen field.
 219 func TestDecodeMaxStrLen(t *testing.T) {
 220         t.Parallel()
 221         c := qt.New(t)
 222         test := func(header, tail string, v interface{}, maxStrLen MaxStrLen) {
 223                 strLen := maxStrLen
 224                 if strLen == 0 {
 225                         strLen = DefaultDecodeMaxStrLen
 226                 }
 227                 c.Assert(decodeHugeString(t, strLen, header, tail, v, maxStrLen), qt.IsNil)
 228                 c.Assert(decodeHugeString(t, strLen+1, header, tail, v, maxStrLen), qt.IsNotNil)
 229         }
 230         test("d%d:", "i0ee", new(interface{}), 0)
 231         test("%d:", "", new(interface{}), DefaultDecodeMaxStrLen)
 232         test("%d:", "", new([]byte), 1)
 233         test("d3:420%d:", "e", new(struct {
 234                 Hi []byte `bencode:"420"`
 235         }), 69)
 236 }
 237
 238 // This is for the "github.com/anacrolix/torrent/metainfo".Info.Private field.
 239 func TestDecodeStringIntoBoolPtr(t *testing.T) {
 240         var m struct {
 241                 Private *bool `bencode:"private,omitempty"`
 242         }
 243         c := qt.New(t)
 244         check := func(msg string, expectNil, expectTrue bool) {
 245                 m.Private = nil
 246                 c.Check(Unmarshal([]byte(msg), &m), qt.IsNil, qt.Commentf("%q", msg))
 247                 if expectNil {
 248                         c.Check(m.Private, qt.IsNil)
 249                 } else {
 250                         if c.Check(m.Private, qt.IsNotNil, qt.Commentf("%q", msg)) {
 251                                 c.Check(*m.Private, qt.Equals, expectTrue, qt.Commentf("%q", msg))
 252                         }
 253                 }
 254         }
 255         check("d7:privatei1ee", false, true)
 256         check("d7:privatei0ee", false, false)
 257         check("d7:privatei42ee", false, true)
 258         // This is a weird case. We could not allocate the bool to indicate it was bad (maybe a bad
 259         // serializer which isn't uncommon), but that requires reworking the decoder to handle
 260         // automatically. I think if we cared enough we'd create a custom Unmarshaler. Also if we were
 261         // worried enough about performance I'd completely rewrite this package.
 262         check("d7:private0:e", false, false)
 263         check("d7:private1:te", false, true)
 264         check("d7:private5:falsee", false, false)
 265         check("d7:private1:Fe", false, false)
 266         check("d7:private11:bunnyfoofooe", false, true)
 267 }