bencode/encode_test.go

   1 package bencode
   2
   3 import (
   4         "bytes"
   5         "fmt"
   6         "math/big"
   7         "testing"
   8
   9         "github.com/stretchr/testify/assert"
  10 )
  11
  12 type random_encode_test struct {
  13         value    interface{}
  14         expected string
  15 }
  16
  17 type random_struct struct {
  18         ABC         int    `bencode:"abc"`
  19         SkipThisOne string `bencode:"-"`
  20         CDE         string
  21 }
  22
  23 type dummy struct {
  24         a, b, c int
  25 }
  26
  27 func (d *dummy) MarshalBencode() ([]byte, error) {
  28         var b bytes.Buffer
  29         _, err := fmt.Fprintf(&b, "i%dei%dei%de", d.a+1, d.b+1, d.c+1)
  30         if err != nil {
  31                 return nil, err
  32         }
  33         return b.Bytes(), nil
  34 }
  35
  36 var random_encode_tests = []random_encode_test{
  37         {int(10), "i10e"},
  38         {uint(10), "i10e"},
  39         {"hello, world", "12:hello, world"},
  40         {true, "i1e"},
  41         {false, "i0e"},
  42         {int8(-8), "i-8e"},
  43         {int16(-16), "i-16e"},
  44         {int32(32), "i32e"},
  45         {int64(-64), "i-64e"},
  46         {uint8(8), "i8e"},
  47         {uint16(16), "i16e"},
  48         {uint32(32), "i32e"},
  49         {uint64(64), "i64e"},
  50         {random_struct{123, "nono", "hello"}, "d3:CDE5:hello3:abci123ee"},
  51         {map[string]string{"a": "b", "c": "d"}, "d1:a1:b1:c1:de"},
  52         {[]byte{1, 2, 3, 4}, "4:\x01\x02\x03\x04"},
  53         {&[4]byte{1, 2, 3, 4}, "4:\x01\x02\x03\x04"},
  54         {nil, ""},
  55         {[]byte{}, "0:"},
  56         {[]byte(nil), "0:"},
  57         {"", "0:"},
  58         {[]int{}, "le"},
  59         {map[string]int{}, "de"},
  60         {&dummy{1, 2, 3}, "i2ei3ei4e"},
  61         {struct {
  62                 A *string
  63         }{nil}, "d1:A0:e"},
  64         {struct {
  65                 A *string
  66         }{new(string)}, "d1:A0:e"},
  67         {struct {
  68                 A *string `bencode:",omitempty"`
  69         }{nil}, "de"},
  70         {struct {
  71                 A *string `bencode:",omitempty"`
  72         }{new(string)}, "d1:A0:e"},
  73         {bigIntFromString("62208002200000000000"), "i62208002200000000000e"},
  74         {*bigIntFromString("62208002200000000000"), "i62208002200000000000e"},
  75 }
  76
  77 func bigIntFromString(s string) *big.Int {
  78         bi, ok := new(big.Int).SetString(s, 10)
  79         if !ok {
  80                 panic(s)
  81         }
  82         return bi
  83 }
  84
  85 func TestRandomEncode(t *testing.T) {
  86         for _, test := range random_encode_tests {
  87                 data, err := Marshal(test.value)
  88                 assert.NoError(t, err, "%s", test)
  89                 assert.EqualValues(t, test.expected, string(data))
  90         }
  91 }