neoneo-go/internal/testserdes/testing.go
Anna Shaleva 6b4dd5703e config: unify BasicService config within existing services
There are no changes visible from the user side (at least for those
users who doesn't put Prometheus's or pprof's port in quotes), just
internal refactoring. From now and on, BasicService configuration is
used by RPC server config, TLS for RPC server, pprof and Prometheus.
2022-12-06 16:35:09 +03:00

98 lines
2.7 KiB
Go

package testserdes
import (
"encoding/json"
"testing"
"github.com/nspcc-dev/neo-go/pkg/io"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/stretchr/testify/require"
"gopkg.in/yaml.v3"
)
// MarshalUnmarshalJSON checks if the expected stays the same after
// marshal/unmarshal via JSON.
func MarshalUnmarshalJSON(t *testing.T, expected, actual interface{}) {
data, err := json.Marshal(expected)
require.NoError(t, err)
require.NoError(t, json.Unmarshal(data, actual))
require.Equal(t, expected, actual)
}
// MarshalUnmarshalYAML checks if the expected stays the same after
// marshal/unmarshal via YAML.
func MarshalUnmarshalYAML(t *testing.T, expected, actual interface{}) {
data, err := yaml.Marshal(expected)
require.NoError(t, err)
require.NoError(t, yaml.Unmarshal(data, actual))
require.Equal(t, expected, actual)
}
// EncodeDecodeBinary checks if the expected stays the same after
// serializing/deserializing via io.Serializable methods.
func EncodeDecodeBinary(t *testing.T, expected, actual io.Serializable) {
data, err := EncodeBinary(expected)
require.NoError(t, err)
require.NoError(t, DecodeBinary(data, actual))
require.Equal(t, expected, actual)
}
// ToFromStackItem checks if the expected stays the same after converting to/from
// StackItem.
func ToFromStackItem(t *testing.T, expected, actual stackitem.Convertible) {
item, err := expected.ToStackItem()
require.NoError(t, err)
require.NoError(t, actual.FromStackItem(item))
require.Equal(t, expected, actual)
}
// EncodeBinary serializes a to a byte slice.
func EncodeBinary(a io.Serializable) ([]byte, error) {
w := io.NewBufBinWriter()
a.EncodeBinary(w.BinWriter)
if w.Err != nil {
return nil, w.Err
}
return w.Bytes(), nil
}
// DecodeBinary deserializes a from a byte slice.
func DecodeBinary(data []byte, a io.Serializable) error {
r := io.NewBinReaderFromBuf(data)
a.DecodeBinary(r)
return r.Err
}
type encodable interface {
Encode(*io.BinWriter) error
Decode(*io.BinReader) error
}
// EncodeDecode checks if the expected stays the same after
// serializing/deserializing via encodable methods.
func EncodeDecode(t *testing.T, expected, actual encodable) {
data, err := Encode(expected)
require.NoError(t, err)
require.NoError(t, Decode(data, actual))
require.Equal(t, expected, actual)
}
// Encode serializes a to a byte slice.
func Encode(a encodable) ([]byte, error) {
w := io.NewBufBinWriter()
err := a.Encode(w.BinWriter)
if err != nil {
return nil, err
}
return w.Bytes(), nil
}
// Decode deserializes a from a byte slice.
func Decode(data []byte, a encodable) error {
r := io.NewBinReaderFromBuf(data)
err := a.Decode(r)
if r.Err != nil {
return r.Err
}
return err
}