go/src/encoding/gob/codec_test.go

var doFuzzTests

type EncodeT

var encodeT

// testError is meant to be used as a deferred function to turn a panic(gobError) into a
// plain test.Error call.
func testError(t *testing.T) {}

func newDecBuffer(data []byte) *decBuffer {}

// Test basic encode/decode routines for unsigned integers
func TestUintCodec(t *testing.T) {}

func verifyInt(i int64, t *testing.T) {}

// Test basic encode/decode routines for signed integers
func TestIntCodec(t *testing.T) {}

var boolResult

var signedResult

var unsignedResult

var floatResult

var complexResult

var bytesResult

func newDecodeState(buf *decBuffer) *decoderState {}

func newEncoderState(b *encBuffer) *encoderState {}

// Test instruction execution for encoding.
// Do not run the machine yet; instead do individual instructions crafted by hand.
func TestScalarEncInstructions(t *testing.T) {}

func execDec(instr *decInstr, state *decoderState, t *testing.T, value reflect.Value) {}

func newDecodeStateFromData(data []byte) *decoderState {}

// Test instruction execution for decoding.
// Do not run the machine yet; instead do individual instructions crafted by hand.
func TestScalarDecInstructions(t *testing.T) {}

func TestEndToEnd(t *testing.T) {}

func TestOverflow(t *testing.T) {}

func TestNesting(t *testing.T) {}

type T0

type T1

type T2

func TestAutoIndirection(t *testing.T) {}

type RT0

type RT1

func TestReorderedFields(t *testing.T) {}

type IT0

func TestIgnoredFields(t *testing.T) {}

func TestBadRecursiveType(t *testing.T) {}

type Indirect

type Direct

func TestIndirectSliceMapArray(t *testing.T) {}

type Squarer

type Int

func (i Int) Square() int {}

type Float

func (f Float) Square() int {}

type Vector

func (v Vector) Square() int {}

type Point

func (p Point) Square() int {}

type InterfaceItem

type NoInterfaceItem

func TestInterface(t *testing.T) {}

type BasicInterfaceItem

func TestInterfaceBasic(t *testing.T) {}

type String

type PtrInterfaceItem

// We'll send pointers; should receive values.
// Also check that we can register T but send *T.
func TestInterfacePointer(t *testing.T) {}

func TestIgnoreInterface(t *testing.T) {}

type U

func TestUnexportedFields(t *testing.T) {}

var singletons

func TestDebugSingleton(t *testing.T) {}

type OnTheFly

type DT

func newDT() DT {}

func TestDebugStruct(t *testing.T) {}

func encFuzzDec(rng *rand.Rand, in any) error {}

// This does some "fuzz testing" by attempting to decode a sequence of random bytes.
func TestFuzz(t *testing.T) {}

func TestFuzzRegressions(t *testing.T) {}

func testFuzz(t *testing.T, seed int64, n int, input ...any) {}

// TestFuzzOneByte tries to decode corrupted input sequences
// and checks that no panic occurs.
func TestFuzzOneByte(t *testing.T) {}

// Don't crash, just give error with invalid type id.
// Issue 9649.
func TestErrorInvalidTypeId(t *testing.T) {}

type LargeSliceByte

type LargeSliceInt8

type StringPair

type LargeSliceStruct

type LargeSliceString

func testEncodeDecode(t *testing.T, in, out any) {}

func TestLargeSlice(t *testing.T) {}

func TestLocalRemoteTypesMismatch(t *testing.T) {}