forked from TrueCloudLab/neoneo-go
433275265f
This is just a much better way to do the same thing. Inspired by nspcc-dev/neofs-sdk-go#407. Signed-off-by: Roman Khimov <roman@nspcc.ru>
257 lines
6.6 KiB
Go
257 lines
6.6 KiB
Go
package stackitem
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/io"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestSerializationMaxErr(t *testing.T) {
|
|
base := make([]byte, MaxSize/2+1)
|
|
item := Make(base)
|
|
|
|
// Pointer is unserializable, but we specifically want to catch ErrTooBig.
|
|
arr := []Item{item, item.Dup(), NewPointer(0, []byte{})}
|
|
aitem := Make(arr)
|
|
|
|
_, err := Serialize(item)
|
|
require.NoError(t, err)
|
|
|
|
_, err = Serialize(aitem)
|
|
require.ErrorIs(t, err, ErrTooBig)
|
|
}
|
|
|
|
func testSerialize(t *testing.T, expectedErr error, item Item) {
|
|
data, err := Serialize(item)
|
|
if expectedErr != nil {
|
|
require.ErrorIs(t, err, expectedErr)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
|
|
actual, err := Deserialize(data)
|
|
require.NoError(t, err)
|
|
require.Equal(t, item, actual)
|
|
}
|
|
|
|
func TestSerialize(t *testing.T) {
|
|
bigByteArray := NewByteArray(make([]byte, MaxSize/2))
|
|
smallByteArray := NewByteArray(make([]byte, MaxSize/4))
|
|
zeroByteArray := NewByteArray(make([]byte, 0))
|
|
testArray := func(t *testing.T, newItem func([]Item) Item) {
|
|
arr := newItem([]Item{bigByteArray})
|
|
testSerialize(t, nil, arr)
|
|
testSerialize(t, ErrTooBig, newItem([]Item{bigByteArray, bigByteArray}))
|
|
testSerialize(t, ErrTooBig, newItem([]Item{arr, arr}))
|
|
|
|
arr.Value().([]Item)[0] = smallByteArray
|
|
testSerialize(t, nil, newItem([]Item{arr, arr}))
|
|
|
|
arr.Value().([]Item)[0] = arr
|
|
testSerialize(t, ErrRecursive, arr)
|
|
|
|
items := make([]Item, 0, MaxDeserialized-1)
|
|
for i := 0; i < MaxDeserialized-1; i++ {
|
|
items = append(items, zeroByteArray)
|
|
}
|
|
testSerialize(t, nil, newItem(items))
|
|
|
|
items = append(items, zeroByteArray)
|
|
data, err := Serialize(newItem(items))
|
|
require.NoError(t, err)
|
|
_, err = Deserialize(data)
|
|
require.ErrorIs(t, err, ErrTooBig)
|
|
}
|
|
t.Run("array", func(t *testing.T) {
|
|
testArray(t, func(items []Item) Item { return NewArray(items) })
|
|
})
|
|
t.Run("struct", func(t *testing.T) {
|
|
testArray(t, func(items []Item) Item { return NewStruct(items) })
|
|
})
|
|
t.Run("buffer", func(t *testing.T) {
|
|
testSerialize(t, nil, NewBuffer(make([]byte, MaxSize/2)))
|
|
testSerialize(t, errTooBigSize, NewBuffer(make([]byte, MaxSize)))
|
|
})
|
|
t.Run("invalid", func(t *testing.T) {
|
|
testSerialize(t, ErrUnserializable, NewInterop(42))
|
|
testSerialize(t, ErrUnserializable, NewPointer(42, []byte{}))
|
|
testSerialize(t, ErrUnserializable, nil)
|
|
|
|
t.Run("protected interop", func(t *testing.T) {
|
|
w := io.NewBufBinWriter()
|
|
EncodeBinaryProtected(NewInterop(42), w.BinWriter)
|
|
require.NoError(t, w.Err)
|
|
|
|
data := w.Bytes()
|
|
r := io.NewBinReaderFromBuf(data)
|
|
DecodeBinary(r)
|
|
require.Error(t, r.Err)
|
|
|
|
r = io.NewBinReaderFromBuf(data)
|
|
item := DecodeBinaryProtected(r)
|
|
require.NoError(t, r.Err)
|
|
require.IsType(t, (*Interop)(nil), item)
|
|
})
|
|
t.Run("protected pointer", func(t *testing.T) {
|
|
w := io.NewBufBinWriter()
|
|
EncodeBinaryProtected(NewPointer(42, []byte{}), w.BinWriter)
|
|
require.NoError(t, w.Err)
|
|
|
|
data := w.Bytes()
|
|
r := io.NewBinReaderFromBuf(data)
|
|
DecodeBinary(r)
|
|
require.Error(t, r.Err)
|
|
|
|
r = io.NewBinReaderFromBuf(data)
|
|
item := DecodeBinaryProtected(r)
|
|
require.NoError(t, r.Err)
|
|
require.IsType(t, (*Pointer)(nil), item)
|
|
require.Equal(t, 42, item.Value())
|
|
})
|
|
t.Run("protected nil", func(t *testing.T) {
|
|
w := io.NewBufBinWriter()
|
|
EncodeBinaryProtected(nil, w.BinWriter)
|
|
require.NoError(t, w.Err)
|
|
|
|
data := w.Bytes()
|
|
r := io.NewBinReaderFromBuf(data)
|
|
DecodeBinary(r)
|
|
require.Error(t, r.Err)
|
|
|
|
r = io.NewBinReaderFromBuf(data)
|
|
item := DecodeBinaryProtected(r)
|
|
require.NoError(t, r.Err)
|
|
require.Nil(t, item)
|
|
})
|
|
})
|
|
t.Run("bool", func(t *testing.T) {
|
|
testSerialize(t, nil, NewBool(true))
|
|
testSerialize(t, nil, NewBool(false))
|
|
})
|
|
t.Run("null", func(t *testing.T) {
|
|
testSerialize(t, nil, Null{})
|
|
})
|
|
t.Run("integer", func(t *testing.T) {
|
|
testSerialize(t, nil, Make(0xF)) // 1-byte
|
|
testSerialize(t, nil, Make(0xFAB)) // 2-byte
|
|
testSerialize(t, nil, Make(0xFABCD)) // 4-byte
|
|
testSerialize(t, nil, Make(0xFABCDEFEDC)) // 8-byte
|
|
})
|
|
t.Run("map", func(t *testing.T) {
|
|
one := Make(1)
|
|
m := NewMap()
|
|
m.Add(one, m)
|
|
testSerialize(t, ErrRecursive, m)
|
|
|
|
m.Add(one, bigByteArray)
|
|
testSerialize(t, nil, m)
|
|
|
|
m.Add(Make(2), bigByteArray)
|
|
testSerialize(t, ErrTooBig, m)
|
|
|
|
// Cover code path when result becomes too big after key encode.
|
|
m = NewMap()
|
|
m.Add(Make(0), NewByteArray(make([]byte, MaxSize-MaxKeySize)))
|
|
m.Add(NewByteArray(make([]byte, MaxKeySize)), Make(1))
|
|
testSerialize(t, ErrTooBig, m)
|
|
|
|
m = NewMap()
|
|
for i := 0; i < MaxDeserialized/2-1; i++ {
|
|
m.Add(Make(i), zeroByteArray)
|
|
}
|
|
testSerialize(t, nil, m)
|
|
|
|
for i := 0; i <= MaxDeserialized; i++ {
|
|
m.Add(Make(i), zeroByteArray)
|
|
}
|
|
data, err := Serialize(m)
|
|
require.NoError(t, err)
|
|
_, err = Deserialize(data)
|
|
require.ErrorIs(t, err, ErrTooBig)
|
|
})
|
|
}
|
|
|
|
func TestEmptyDeserialization(t *testing.T) {
|
|
empty := []byte{}
|
|
_, err := Deserialize(empty)
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestMapDeserializationError(t *testing.T) {
|
|
m := NewMap()
|
|
m.Add(Make(1), Make(1))
|
|
m.Add(Make(2), nil) // Bad value
|
|
m.Add(Make(3), Make(3))
|
|
|
|
w := io.NewBufBinWriter()
|
|
EncodeBinaryProtected(m, w.BinWriter)
|
|
require.NoError(t, w.Err)
|
|
_, err := Deserialize(w.Bytes())
|
|
require.ErrorIs(t, err, ErrInvalidType)
|
|
}
|
|
|
|
func TestDeserializeTooManyElements(t *testing.T) {
|
|
item := Make(0)
|
|
for i := 0; i < MaxDeserialized-1; i++ { // 1 for zero inner element.
|
|
item = Make([]Item{item})
|
|
}
|
|
data, err := Serialize(item)
|
|
require.NoError(t, err)
|
|
_, err = Deserialize(data)
|
|
require.NoError(t, err)
|
|
|
|
item = Make([]Item{item})
|
|
data, err = Serialize(item)
|
|
require.NoError(t, err)
|
|
_, err = Deserialize(data)
|
|
require.ErrorIs(t, err, ErrTooBig)
|
|
}
|
|
|
|
func TestDeserializeLimited(t *testing.T) {
|
|
customLimit := MaxDeserialized + 1
|
|
item := Make(0)
|
|
for i := 0; i < customLimit-1; i++ { // 1 for zero inner element.
|
|
item = Make([]Item{item})
|
|
}
|
|
data, err := Serialize(item)
|
|
require.NoError(t, err)
|
|
actual, err := DeserializeLimited(data, customLimit)
|
|
require.NoError(t, err)
|
|
require.Equal(t, item, actual)
|
|
|
|
item = Make([]Item{item})
|
|
data, err = Serialize(item)
|
|
require.NoError(t, err)
|
|
_, err = DeserializeLimited(data, customLimit)
|
|
require.Error(t, err)
|
|
require.ErrorIs(t, err, ErrTooBig)
|
|
}
|
|
|
|
func BenchmarkEncodeBinary(b *testing.B) {
|
|
arr := getBigArray(15)
|
|
|
|
w := io.NewBufBinWriter()
|
|
|
|
b.ResetTimer()
|
|
b.ReportAllocs()
|
|
for i := 0; i < b.N; i++ {
|
|
w.Reset()
|
|
EncodeBinary(arr, w.BinWriter)
|
|
if w.Err != nil {
|
|
b.FailNow()
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkSerializeSimple(b *testing.B) {
|
|
s := NewStruct(nil)
|
|
s.Append(Make(100500))
|
|
s.Append(Make("1aada0032aba1ef6d1f0")) // Mimicking uint160.
|
|
for i := 0; i < b.N; i++ {
|
|
_, err := Serialize(s)
|
|
if err != nil {
|
|
b.FailNow()
|
|
}
|
|
}
|
|
}
|