github.com/sixexorg/magnetic-ring@v0.0.0-20191119090307-31705a21e419/common/sink/serialize_test.go (about)

     1  package sink
     2  
     3  import (
     4  	"bytes"
     5  	"crypto/rand"
     6  	"fmt"
     7  	"io/ioutil"
     8  	"math"
     9  	"testing"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func BenchmarkWriteVarUint(b *testing.B) {
    15  	n := uint64(math.MaxUint64)
    16  	for i := 0; i < b.N; i++ {
    17  		WriteVarUint(ioutil.Discard, n)
    18  	}
    19  }
    20  
    21  func BenchmarkWriteVarBytes(b *testing.B) {
    22  	s := []byte{10, 11, 12}
    23  	buf := new(bytes.Buffer)
    24  	for i := 0; i < b.N; i++ {
    25  		WriteVarBytes(buf, s)
    26  	}
    27  }
    28  
    29  func BenchmarkWriteVarString(b *testing.B) {
    30  	s := "jim"
    31  	buf := new(bytes.Buffer)
    32  	for i := 0; i < b.N; i++ {
    33  		WriteString(buf, s)
    34  	}
    35  }
    36  
    37  func BenchmarkReadVarUint(b *testing.B) {
    38  	data := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
    39  	for i := 0; i < b.N; i++ {
    40  		r := bytes.NewReader(data)
    41  		ReadVarUint(r, 0)
    42  	}
    43  }
    44  
    45  func BenchmarkReadVarBytes(b *testing.B) {
    46  	data := []byte{10, 11, 12}
    47  	for i := 0; i < b.N; i++ {
    48  		r := bytes.NewReader(data)
    49  		ReadVarBytes(r)
    50  	}
    51  }
    52  
    53  func BenchmarkReadVarString(b *testing.B) {
    54  	data := []byte{10, 11, 12}
    55  	for i := 0; i < b.N; i++ {
    56  		r := bytes.NewReader(data)
    57  		ReadString(r)
    58  	}
    59  }
    60  
    61  func BenchmarkSerialize(ben *testing.B) {
    62  	a3 := uint8(100)
    63  	a4 := uint16(65535)
    64  	a5 := uint32(4294967295)
    65  	a6 := uint64(18446744073709551615)
    66  	a7 := uint64(18446744073709551615)
    67  	a8 := []byte{10, 11, 12}
    68  	a9 := "hello onchain."
    69  	for i := 0; i < ben.N; i++ {
    70  		b := new(bytes.Buffer)
    71  
    72  		WriteVarUint(b, uint64(a3))
    73  		WriteVarUint(b, uint64(a4))
    74  		WriteVarUint(b, uint64(a5))
    75  		WriteVarUint(b, uint64(a6))
    76  		WriteVarUint(b, uint64(a7))
    77  		WriteVarBytes(b, a8)
    78  		WriteString(b, a9)
    79  
    80  		ReadVarUint(b, math.MaxUint64)
    81  		ReadVarUint(b, math.MaxUint64)
    82  		ReadVarUint(b, math.MaxUint64)
    83  		ReadVarUint(b, math.MaxUint64)
    84  		ReadVarUint(b, math.MaxUint32)
    85  		ReadVarBytes(b)
    86  		ReadString(b)
    87  
    88  		GetVarUintSize(uint64(100))
    89  		GetVarUintSize(uint64(65535))
    90  		GetVarUintSize(uint64(4294967295))
    91  		GetVarUintSize(uint64(18446744073709551615))
    92  
    93  		b.WriteByte(20)
    94  		b.WriteByte(21)
    95  		b.WriteByte(22)
    96  		ReadBytes(b, uint64(3))
    97  	}
    98  
    99  }
   100  
   101  func TestSerialize(t *testing.T) {
   102  	b := new(bytes.Buffer)
   103  	a3 := uint8(100)
   104  	a4 := uint16(65535)
   105  	a5 := uint32(4294967295)
   106  	a6 := uint64(18446744073709551615)
   107  	a7 := uint64(18446744073709551615)
   108  	a8 := []byte{10, 11, 12}
   109  	a9 := "hello onchain."
   110  
   111  	WriteVarUint(b, uint64(a3))
   112  	WriteVarUint(b, uint64(a4))
   113  	WriteVarUint(b, uint64(a5))
   114  	WriteVarUint(b, uint64(a6))
   115  	WriteVarUint(b, uint64(a7))
   116  	WriteVarBytes(b, a8)
   117  	WriteString(b, a9)
   118  
   119  	fmt.Println(ReadVarUint(b, math.MaxUint64))
   120  	fmt.Println(ReadVarUint(b, math.MaxUint64))
   121  	fmt.Println(ReadVarUint(b, math.MaxUint64))
   122  	fmt.Println(ReadVarUint(b, math.MaxUint64))
   123  	fmt.Println(ReadVarUint(b, math.MaxUint32))
   124  	fmt.Println(ReadVarBytes(b))
   125  	fmt.Println(ReadString(b))
   126  
   127  	fmt.Printf("100 size is %d byte.\t\n", GetVarUintSize(uint64(100)))
   128  	fmt.Printf("65535 size is %d byte.\t\n", GetVarUintSize(uint64(65535)))
   129  	fmt.Printf("4294967295 size is %d byte.\t\n", GetVarUintSize(uint64(4294967295)))
   130  	fmt.Printf("18446744073709551615 size is %d byte.\t\n", GetVarUintSize(uint64(18446744073709551615)))
   131  
   132  	b.WriteByte(20)
   133  	b.WriteByte(21)
   134  	b.WriteByte(22)
   135  	fmt.Println(ReadBytes(b, uint64(3)))
   136  
   137  }
   138  
   139  func TestReadWriteInt(t *testing.T) {
   140  	b3 := new(bytes.Buffer)
   141  	b4 := new(bytes.Buffer)
   142  	b5 := new(bytes.Buffer)
   143  	b6 := new(bytes.Buffer)
   144  
   145  	a3 := uint8(100)
   146  	a4 := uint16(65535)
   147  	a5 := uint32(4294967295)
   148  	a6 := uint64(18446744073709551615)
   149  
   150  	WriteUint8(b3, a3)
   151  	WriteUint16(b4, a4)
   152  	WriteUint32(b5, a5)
   153  	WriteUint64(b6, a6)
   154  
   155  	fmt.Printf("uint8 %x\n", b3.Bytes())
   156  	fmt.Printf("uint16 %x\n", b4.Bytes())
   157  	fmt.Printf("uint32 %x\n", b5.Bytes())
   158  	fmt.Printf("uint63 %x\n", b6.Bytes())
   159  
   160  	fmt.Println(ReadUint8(b3))
   161  	fmt.Println(ReadUint16(b4))
   162  	fmt.Println(ReadUint32(b5))
   163  	fmt.Println(ReadUint64(b6))
   164  
   165  }
   166  
   167  func TestReadVarBytesMemAllocAttack(t *testing.T) {
   168  	buff := bytes.NewBuffer([]byte{1, 2, 3})
   169  	length := math.MaxInt64
   170  	_, err := byteXReader(buff, uint64(length))
   171  	assert.NotNil(t, err)
   172  }
   173  
   174  func TestReadVarBytesRead(t *testing.T) {
   175  	bs := make([]byte, 2048+1)
   176  	for i := 0; i < len(bs); i++ {
   177  		bs[i] = byte(i)
   178  	}
   179  	buff := bytes.NewBuffer(bs)
   180  	read, err := byteXReader(buff, uint64(len(bs)))
   181  	assert.Nil(t, err)
   182  	assert.Equal(t, bs, read)
   183  }
   184  
   185  const N = 24829*1 + 1
   186  
   187  func BenchmarkBytesXReader(b *testing.B) {
   188  	bs := make([]byte, N)
   189  	rand.Read(bs)
   190  	for i := 0; i < b.N; i++ {
   191  		buff := bytes.NewBuffer(bs)
   192  		byteXReader(buff, uint64(len(bs)))
   193  	}
   194  }