go/src/encoding/gob/gobencdec_test.go

type ByteStruct

type StringStruct

type ArrayStruct

type Gobber

type ValueGobber

type BinaryGobber

type BinaryValueGobber

type TextGobber

type TextValueGobber

func (g *ByteStruct) GobEncode() ([]byte, error) {}

func (g *ByteStruct) GobDecode(data []byte) error {}

func (g *StringStruct) GobEncode() ([]byte, error) {}

func (g *StringStruct) GobDecode(data []byte) error {}

func (a *ArrayStruct) GobEncode() ([]byte, error) {}

func (a *ArrayStruct) GobDecode(data []byte) error {}

func (g *Gobber) GobEncode() ([]byte, error) {}

func (g *Gobber) GobDecode(data []byte) error {}

func (g *BinaryGobber) MarshalBinary() ([]byte, error) {}

func (g *BinaryGobber) UnmarshalBinary(data []byte) error {}

func (g *TextGobber) MarshalText() ([]byte, error) {}

func (g *TextGobber) UnmarshalText(data []byte) error {}

func (v ValueGobber) GobEncode() ([]byte, error) {}

func (v *ValueGobber) GobDecode(data []byte) error {}

func (v BinaryValueGobber) MarshalBinary() ([]byte, error) {}

func (v *BinaryValueGobber) UnmarshalBinary(data []byte) error {}

func (v TextValueGobber) MarshalText() ([]byte, error) {}

func (v *TextValueGobber) UnmarshalText(data []byte) error {}

type GobTest0

type GobTest1

type GobTest2

type GobTest3

type GobTest4

type GobTest5

type GobTest6

type GobTest7

type GobTestIgnoreEncoder

type GobTestValueEncDec

type GobTestIndirectEncDec

type GobTestArrayEncDec

type GobTestIndirectArrayEncDec

func TestGobEncoderField(t *testing.T) {}

// Even though the field is a value, we can still take its address
// and should be able to call the methods.
func TestGobEncoderValueField(t *testing.T) {}

// GobEncode/Decode should work even if the value is
// more indirect than the receiver.
func TestGobEncoderIndirectField(t *testing.T) {}

// Test with a large field with methods.
func TestGobEncoderArrayField(t *testing.T) {}

// Test an indirection to a large field with methods.
func TestGobEncoderIndirectArrayField(t *testing.T) {}

// As long as the fields have the same name and implement the
// interface, we can cross-connect them. Not sure it's useful
// and may even be bad but it works and it's hard to prevent
// without exposing the contents of the object, which would
// defeat the purpose.
func TestGobEncoderFieldsOfDifferentType(t *testing.T) {}

// Test that we can encode a value and decode into a pointer.
func TestGobEncoderValueEncoder(t *testing.T) {}

// Test that we can use a value then a pointer type of a GobEncoder
// in the same encoded value. Bug 4647.
func TestGobEncoderValueThenPointer(t *testing.T) {}

// Test that we can use a pointer then a value type of a GobEncoder
// in the same encoded value.
func TestGobEncoderPointerThenValue(t *testing.T) {}

func TestGobEncoderFieldTypeError(t *testing.T) {}

// Even though ByteStruct is a struct, it's treated as a singleton at the top level.
func TestGobEncoderStructSingleton(t *testing.T) {}

func TestGobEncoderNonStructSingleton(t *testing.T) {}

func TestGobEncoderIgnoreStructField(t *testing.T) {}

func TestGobEncoderIgnoreNonStructField(t *testing.T) {}

func TestGobEncoderIgnoreNilEncoder(t *testing.T) {}

type gobDecoderBug0

func (br *gobDecoderBug0) String() string {}

func (br *gobDecoderBug0) GobEncode() ([]byte, error) {}

func (br *gobDecoderBug0) GobDecode(b []byte) error {}

// This was a bug: the receiver has a different indirection level
// than the variable.
func TestGobEncoderExtraIndirect(t *testing.T) {}

type isZeroBug

type isZeroBugArray

// Receiver is value, not pointer, to test isZero of array.
func (a isZeroBugArray) GobEncode() (b []byte, e error) {}

func (a *isZeroBugArray) GobDecode(data []byte) error {}

type isZeroBugInterface

func (i isZeroBugInterface) GobEncode() (b []byte, e error) {}

func (i *isZeroBugInterface) GobDecode(data []byte) error {}

func TestGobEncodeIsZero(t *testing.T) {}

func TestGobEncodePtrError(t *testing.T) {}

func TestNetIP(t *testing.T) {}

func TestIgnoreDepthLimit(t *testing.T) {}