codec

package
v1.10.10 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 12, 2024 License: BSD-3-Clause Imports: 10 Imported by: 13

Documentation

Overview

Package codec is a generated GoMock package.

Index

Constants

This section is empty.

Variables

View Source
var (
	ErrUnsupportedType           = errors.New("unsupported type")
	ErrMaxSliceLenExceeded       = errors.New("max slice length exceeded")
	ErrDoesNotImplementInterface = errors.New("does not implement interface")
	ErrUnexportedField           = errors.New("unexported field")
	ErrExtraSpace                = errors.New("trailing buffer space")
)
View Source
var (
	ErrUnknownVersion    = errors.New("unknown codec version")
	ErrMarshalNil        = errors.New("can't marshal nil pointer or interface")
	ErrUnmarshalNil      = errors.New("can't unmarshal nil")
	ErrUnmarshalTooBig   = errors.New("byte array exceeds maximum length")
	ErrCantPackVersion   = errors.New("couldn't pack codec version")
	ErrCantUnpackVersion = errors.New("couldn't unpack codec version")
	ErrDuplicatedVersion = errors.New("duplicated codec version")
)
View Source
var ErrDuplicateType = errors.New("duplicate type registration")

Functions

func FuzzStructUnmarshal

func FuzzStructUnmarshal(codec GeneralCodec, f *testing.F)

func TestArray

func TestArray(codec GeneralCodec, t testing.TB)

Test marshalling an array

func TestArrayOfInterface

func TestArrayOfInterface(codec GeneralCodec, t testing.TB)

Test marshalling an array of interfaces

func TestBigArray

func TestBigArray(codec GeneralCodec, t testing.TB)

Test marshalling a really big array

func TestBool

func TestBool(codec GeneralCodec, t testing.TB)

Test marshalling a bool

func TestEmptySliceSerialization

func TestEmptySliceSerialization(codec GeneralCodec, t testing.TB)

Test marshaling a slice that has 0 elements (but isn't nil)

func TestExtraSpace

func TestExtraSpace(codec GeneralCodec, t testing.TB)

Test unmarshaling something with extra data

func TestInterface

func TestInterface(codec GeneralCodec, t testing.TB)

Test marshalling an interface

func TestMap

func TestMap(codec GeneralCodec, t testing.TB)

func TestMaxSizeSlice

func TestMaxSizeSlice(codec GeneralCodec, t testing.TB)

Test marshalling/unmarshalling largest possible slice

func TestMultipleTags

func TestMultipleTags(codec GeneralCodec, t testing.TB)

func TestNegativeNumbers

func TestNegativeNumbers(codec GeneralCodec, t testing.TB)

Ensure serializing structs with negative number members works

func TestNilSlice

func TestNilSlice(codec GeneralCodec, t testing.TB)

Ensure a nil slice is unmarshaled to slice with length 0

func TestNilSliceSerialization

func TestNilSliceSerialization(codec GeneralCodec, t testing.TB)

Test marshalling of nil slice

func TestPointerToInterface

func TestPointerToInterface(codec GeneralCodec, t testing.TB)

Test marshalling a pointer to an interface

func TestPointerToStruct

func TestPointerToStruct(codec GeneralCodec, t testing.TB)

Test marshalling a pointer to a struct

func TestRegisterStructTwice

func TestRegisterStructTwice(codec GeneralCodec, t testing.TB)

func TestRestrictedSlice

func TestRestrictedSlice(codec GeneralCodec, t testing.TB)

Ensure deserializing slices that have been length restricted errors correctly

func TestSerializeOfNoSerializeField

func TestSerializeOfNoSerializeField(codec GeneralCodec, t testing.TB)

func TestSerializeUnexportedField

func TestSerializeUnexportedField(codec GeneralCodec, t testing.TB)

Ensure that trying to serialize a struct with an unexported member that has `serialize:"true"` returns error

func TestSlice

func TestSlice(codec GeneralCodec, t testing.TB)

func TestSliceLengthOverflow

func TestSliceLengthOverflow(codec GeneralCodec, t testing.TB)

Ensure deserializing slices that have been length restricted errors correctly

func TestSliceOfInterface

func TestSliceOfInterface(codec GeneralCodec, t testing.TB)

Test marshalling a slice of interfaces

func TestSliceOfStruct

func TestSliceOfStruct(codec GeneralCodec, t testing.TB)

Test marshalling a slice of structs

func TestSliceTooLarge

func TestSliceTooLarge(codec GeneralCodec, t testing.TB)

func TestSliceWithEmptySerialization

func TestSliceWithEmptySerialization(codec GeneralCodec, t testing.TB)

Test marshaling slice that is not nil and not empty

func TestSliceWithEmptySerializationOutOfMemory

func TestSliceWithEmptySerializationOutOfMemory(codec GeneralCodec, t testing.TB)

func TestString

func TestString(codec GeneralCodec, t testing.TB)

Test marshalling a string

func TestStruct

func TestStruct(codec GeneralCodec, t testing.TB)

Test marshaling/unmarshaling a complicated struct

func TestTooLargeUnmarshal

func TestTooLargeUnmarshal(codec GeneralCodec, t testing.TB)

Ensure deserializing structs with too many bytes errors correctly

func TestUInt32

func TestUInt32(codec GeneralCodec, t testing.TB)

func TestUIntPtr

func TestUIntPtr(codec GeneralCodec, t testing.TB)

func TestUnmarshalInvalidInterface

func TestUnmarshalInvalidInterface(codec GeneralCodec, t testing.TB)

Ensure deserializing structs into the wrong interface errors gracefully

Types

type Codec

type Codec interface {
	MarshalInto(interface{}, *wrappers.Packer) error
	Unmarshal([]byte, interface{}) error

	// Returns the size, in bytes, of [value] when it's marshaled
	Size(value interface{}) (int, error)
}

Codec marshals and unmarshals

type Foo

type Foo interface {
	Foo() int
}

type GeneralCodec

type GeneralCodec interface {
	Codec
	Registry
}

GeneralCodec marshals and unmarshals structs including interfaces

type Manager

type Manager interface {
	// Associate the given codec with the given version ID
	RegisterCodec(version uint16, codec Codec) error

	// Size returns the size, in bytes, of [value] when it's marshaled
	// using the codec with the given version.
	// RegisterCodec must have been called with that version.
	// If [value] is nil, returns [ErrMarshalNil]
	Size(version uint16, value interface{}) (int, error)

	// Marshal the given value using the codec with the given version.
	// RegisterCodec must have been called with that version.
	Marshal(version uint16, source interface{}) (destination []byte, err error)

	// Unmarshal the given bytes into the given destination. [destination] must
	// be a pointer or an interface. Returns the version of the codec that
	// produces the given bytes.
	Unmarshal(source []byte, destination interface{}) (version uint16, err error)
}

Manager describes the functionality for managing codec versions.

func NewDefaultManager

func NewDefaultManager() Manager

NewDefaultManager returns a new codec manager.

func NewManager

func NewManager(maxSize int) Manager

NewManager returns a new codec manager.

type MockManager

type MockManager struct {
	// contains filtered or unexported fields
}

MockManager is a mock of Manager interface.

func NewMockManager

func NewMockManager(ctrl *gomock.Controller) *MockManager

NewMockManager creates a new mock instance.

func (*MockManager) EXPECT

func (m *MockManager) EXPECT() *MockManagerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockManager) Marshal

func (m *MockManager) Marshal(arg0 uint16, arg1 interface{}) ([]byte, error)

Marshal mocks base method.

func (*MockManager) RegisterCodec

func (m *MockManager) RegisterCodec(arg0 uint16, arg1 Codec) error

RegisterCodec mocks base method.

func (*MockManager) Size

func (m *MockManager) Size(arg0 uint16, arg1 interface{}) (int, error)

Size mocks base method.

func (*MockManager) Unmarshal

func (m *MockManager) Unmarshal(arg0 []byte, arg1 interface{}) (uint16, error)

Unmarshal mocks base method.

type MockManagerMockRecorder

type MockManagerMockRecorder struct {
	// contains filtered or unexported fields
}

MockManagerMockRecorder is the mock recorder for MockManager.

func (*MockManagerMockRecorder) Marshal

func (mr *MockManagerMockRecorder) Marshal(arg0, arg1 interface{}) *gomock.Call

Marshal indicates an expected call of Marshal.

func (*MockManagerMockRecorder) RegisterCodec

func (mr *MockManagerMockRecorder) RegisterCodec(arg0, arg1 interface{}) *gomock.Call

RegisterCodec indicates an expected call of RegisterCodec.

func (*MockManagerMockRecorder) Size

func (mr *MockManagerMockRecorder) Size(arg0, arg1 interface{}) *gomock.Call

Size indicates an expected call of Size.

func (*MockManagerMockRecorder) Unmarshal

func (mr *MockManagerMockRecorder) Unmarshal(arg0, arg1 interface{}) *gomock.Call

Unmarshal indicates an expected call of Unmarshal.

type MultipleVersionsStruct

type MultipleVersionsStruct struct {
	BothTags    string `tag1:"true" tag2:"true"`
	SingleTag1  string `tag1:"true"`
	SingleTag2  string `tag2:"true"`
	EitherTags1 string `tag1:"false" tag2:"true"`
	EitherTags2 string `tag1:"true" tag2:"false"`
	NoTags      string `tag1:"false" tag2:"false"`
}

type MyInnerStruct

type MyInnerStruct struct {
	Str string `serialize:"true"`
}

func (*MyInnerStruct) Foo

func (*MyInnerStruct) Foo() int

type MyInnerStruct2

type MyInnerStruct2 struct {
	Bool bool `serialize:"true"`
}

func (*MyInnerStruct2) Foo

func (*MyInnerStruct2) Foo() int

type MyInnerStruct3

type MyInnerStruct3 struct {
	Str string        `serialize:"true"`
	M1  MyInnerStruct `serialize:"true"`
	F   Foo           `serialize:"true"`
}

MyInnerStruct3 embeds Foo, an interface, so it has to implement TypeID and ConcreteInstance

type Registry

type Registry interface {
	RegisterType(interface{}) error
}

Registry registers new types that can be marshaled into

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL