238 lines
6.2 KiB
Go
238 lines
6.2 KiB
Go
package bencode
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
"reflect"
|
|
"testing"
|
|
|
|
qt "github.com/frankban/quicktest"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type random_decode_test struct {
|
|
data string
|
|
expected interface{}
|
|
}
|
|
|
|
var random_decode_tests = []random_decode_test{
|
|
{"i57e", int64(57)},
|
|
{"i-9223372036854775808e", int64(-9223372036854775808)},
|
|
{"5:hello", "hello"},
|
|
{"29:unicode test проверка", "unicode test проверка"},
|
|
{"d1:ai5e1:b5:helloe", map[string]interface{}{"a": int64(5), "b": "hello"}},
|
|
{
|
|
"li5ei10ei15ei20e7:bencodee",
|
|
[]interface{}{int64(5), int64(10), int64(15), int64(20), "bencode"},
|
|
},
|
|
{"ldedee", []interface{}{map[string]interface{}{}, map[string]interface{}{}}},
|
|
{"le", []interface{}{}},
|
|
{"i604919719469385652980544193299329427705624352086e", func() *big.Int {
|
|
ret, _ := big.NewInt(-1).SetString("604919719469385652980544193299329427705624352086", 10)
|
|
return ret
|
|
}()},
|
|
{"d1:rd6:\xd4/\xe2F\x00\x01i42ee1:t3:\x9a\x87\x011:v4:TR%=1:y1:re", map[string]interface{}{
|
|
"r": map[string]interface{}{"\xd4/\xe2F\x00\x01": int64(42)},
|
|
"t": "\x9a\x87\x01",
|
|
"v": "TR%=",
|
|
"y": "r",
|
|
}},
|
|
{"d0:i420ee", map[string]interface{}{"": int64(420)}},
|
|
}
|
|
|
|
func TestRandomDecode(t *testing.T) {
|
|
for _, test := range random_decode_tests {
|
|
var value interface{}
|
|
err := Unmarshal([]byte(test.data), &value)
|
|
if err != nil {
|
|
t.Error(err, test.data)
|
|
continue
|
|
}
|
|
assert.EqualValues(t, test.expected, value)
|
|
}
|
|
}
|
|
|
|
func TestLoneE(t *testing.T) {
|
|
var v int
|
|
err := Unmarshal([]byte("e"), &v)
|
|
se := err.(*SyntaxError)
|
|
require.EqualValues(t, 0, se.Offset)
|
|
}
|
|
|
|
func TestDecoderConsecutive(t *testing.T) {
|
|
d := NewDecoder(bytes.NewReader([]byte("i1ei2e")))
|
|
var i int
|
|
err := d.Decode(&i)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 1, i)
|
|
err = d.Decode(&i)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 2, i)
|
|
err = d.Decode(&i)
|
|
require.Equal(t, io.EOF, err)
|
|
}
|
|
|
|
func TestDecoderConsecutiveDicts(t *testing.T) {
|
|
bb := bytes.NewBufferString("d4:herp4:derped3:wat1:ke17:oh baby a triple!")
|
|
|
|
d := NewDecoder(bb)
|
|
assert.EqualValues(t, "d4:herp4:derped3:wat1:ke17:oh baby a triple!", bb.Bytes())
|
|
assert.EqualValues(t, 0, d.Offset)
|
|
|
|
var m map[string]interface{}
|
|
|
|
require.NoError(t, d.Decode(&m))
|
|
assert.Len(t, m, 1)
|
|
assert.Equal(t, "derp", m["herp"])
|
|
assert.Equal(t, "d3:wat1:ke17:oh baby a triple!", bb.String())
|
|
assert.EqualValues(t, 14, d.Offset)
|
|
|
|
require.NoError(t, d.Decode(&m))
|
|
assert.Equal(t, "k", m["wat"])
|
|
assert.Equal(t, "17:oh baby a triple!", bb.String())
|
|
assert.EqualValues(t, 24, d.Offset)
|
|
|
|
var s string
|
|
require.NoError(t, d.Decode(&s))
|
|
assert.Equal(t, "oh baby a triple!", s)
|
|
assert.EqualValues(t, 44, d.Offset)
|
|
}
|
|
|
|
func check_error(t *testing.T, err error) {
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func assert_equal(t *testing.T, x, y interface{}) {
|
|
if !reflect.DeepEqual(x, y) {
|
|
t.Errorf("got: %v (%T), expected: %v (%T)\n", x, x, y, y)
|
|
}
|
|
}
|
|
|
|
type unmarshalerInt struct {
|
|
x int
|
|
}
|
|
|
|
func (me *unmarshalerInt) UnmarshalBencode(data []byte) error {
|
|
return Unmarshal(data, &me.x)
|
|
}
|
|
|
|
type unmarshalerString struct {
|
|
x string
|
|
}
|
|
|
|
func (me *unmarshalerString) UnmarshalBencode(data []byte) error {
|
|
me.x = string(data)
|
|
return nil
|
|
}
|
|
|
|
func TestUnmarshalerBencode(t *testing.T) {
|
|
var i unmarshalerInt
|
|
var ss []unmarshalerString
|
|
check_error(t, Unmarshal([]byte("i71e"), &i))
|
|
assert_equal(t, i.x, 71)
|
|
check_error(t, Unmarshal([]byte("l5:hello5:fruit3:waye"), &ss))
|
|
assert_equal(t, ss[0].x, "5:hello")
|
|
assert_equal(t, ss[1].x, "5:fruit")
|
|
assert_equal(t, ss[2].x, "3:way")
|
|
}
|
|
|
|
func TestIgnoreUnmarshalTypeError(t *testing.T) {
|
|
s := struct {
|
|
Ignore int `bencode:",ignore_unmarshal_type_error"`
|
|
Normal int
|
|
}{}
|
|
require.Error(t, Unmarshal([]byte("d6:Normal5:helloe"), &s))
|
|
assert.NoError(t, Unmarshal([]byte("d6:Ignore5:helloe"), &s))
|
|
qt.Assert(t, Unmarshal([]byte("d6:Ignorei42ee"), &s), qt.IsNil)
|
|
assert.EqualValues(t, 42, s.Ignore)
|
|
}
|
|
|
|
// Test unmarshalling []byte into something that has the same kind but
|
|
// different type.
|
|
func TestDecodeCustomSlice(t *testing.T) {
|
|
type flag byte
|
|
var fs3, fs2 []flag
|
|
// We do a longer slice then a shorter slice to see if the buffers are
|
|
// shared.
|
|
d := NewDecoder(bytes.NewBufferString("3:\x01\x10\xff2:\x04\x0f"))
|
|
require.NoError(t, d.Decode(&fs3))
|
|
require.NoError(t, d.Decode(&fs2))
|
|
assert.EqualValues(t, []flag{1, 16, 255}, fs3)
|
|
assert.EqualValues(t, []flag{4, 15}, fs2)
|
|
}
|
|
|
|
func TestUnmarshalUnusedBytes(t *testing.T) {
|
|
var i int
|
|
require.EqualValues(t, ErrUnusedTrailingBytes{1}, Unmarshal([]byte("i42ee"), &i))
|
|
assert.EqualValues(t, 42, i)
|
|
}
|
|
|
|
func TestUnmarshalByteArray(t *testing.T) {
|
|
var ba [2]byte
|
|
assert.NoError(t, Unmarshal([]byte("2:hi"), &ba))
|
|
assert.EqualValues(t, "hi", ba[:])
|
|
}
|
|
|
|
func TestDecodeDictIntoUnsupported(t *testing.T) {
|
|
// Any type that a dict shouldn't be unmarshallable into.
|
|
var i int
|
|
c := qt.New(t)
|
|
err := Unmarshal([]byte("d1:a1:be"), &i)
|
|
t.Log(err)
|
|
c.Check(err, qt.Not(qt.IsNil))
|
|
}
|
|
|
|
func TestUnmarshalDictKeyNotString(t *testing.T) {
|
|
// Any type that a dict shouldn't be unmarshallable into.
|
|
var i int
|
|
c := qt.New(t)
|
|
err := Unmarshal([]byte("di42e3:yese"), &i)
|
|
t.Log(err)
|
|
c.Check(err, qt.Not(qt.IsNil))
|
|
}
|
|
|
|
type arbitraryReader struct{}
|
|
|
|
func (arbitraryReader) Read(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
|
|
func decodeHugeString(t *testing.T, strLen int64, header, tail string, v interface{}, maxStrLen MaxStrLen) error {
|
|
r, w := io.Pipe()
|
|
go func() {
|
|
fmt.Fprintf(w, header, strLen)
|
|
io.CopyN(w, arbitraryReader{}, strLen)
|
|
w.Write([]byte(tail))
|
|
w.Close()
|
|
}()
|
|
d := NewDecoder(r)
|
|
d.MaxStrLen = maxStrLen
|
|
return d.Decode(v)
|
|
|
|
}
|
|
|
|
// Ensure that bencode strings in various places obey the Decoder.MaxStrLen field.
|
|
func TestDecodeMaxStrLen(t *testing.T) {
|
|
t.Parallel()
|
|
c := qt.New(t)
|
|
test := func(header, tail string, v interface{}, maxStrLen MaxStrLen) {
|
|
strLen := maxStrLen
|
|
if strLen == 0 {
|
|
strLen = DefaultDecodeMaxStrLen
|
|
}
|
|
c.Assert(decodeHugeString(t, strLen, header, tail, v, maxStrLen), qt.IsNil)
|
|
c.Assert(decodeHugeString(t, strLen+1, header, tail, v, maxStrLen), qt.IsNotNil)
|
|
}
|
|
test("d%d:", "i0ee", new(interface{}), 0)
|
|
test("%d:", "", new(interface{}), DefaultDecodeMaxStrLen)
|
|
test("%d:", "", new([]byte), 1)
|
|
test("d3:420%d:", "e", new(struct {
|
|
Hi []byte `bencode:"420"`
|
|
}), 69)
|
|
}
|