testutils

type AnotherEvent ¶

type AnotherEvent struct {
	Data string
}

func (AnotherEvent) Name() string

type CommandA ¶ added in v0.10.0

type CommandA struct {
	X, Y, Z float64
}

func (CommandA) Name() string

type CommandB ¶ added in v0.10.0

type CommandB struct {
	ID      uint64
	Label   string
	Enabled bool
}

func (CommandB) Name() string

type CommandC ¶ added in v0.10.0

type CommandC struct {
	Values  [8]int32
	Counter uint16
}

func (CommandC) Name() string

type ComponentA ¶

type ComponentA struct {
	X, Y, Z float64
}

func (ComponentA) Name() string

type ComponentB ¶

type ComponentB struct {
	ID      uint64
	Label   string
	Enabled bool
}

func (ComponentB) Name() string

type ComponentC ¶

type ComponentC struct {
	Values  [8]int32
	Counter uint16
}

func (ComponentC) Name() string

type ComponentMixed ¶ added in v0.10.0

type ComponentMixed struct {
	// Integer types
	Int8Val   int8
	Int16Val  int16
	Int32Val  int32
	Int64Val  int64
	Uint8Val  uint8
	Uint16Val uint16
	Uint32Val uint32
	Uint64Val uint64 // Critical: values > 2^53-1 lose precision in JSON

	// Floating point
	Float32Val float32
	Float64Val float64

	// String and bool
	StringVal string
	BoolVal   bool

	// Slice and array
	IntSlice   []int
	ByteSlice  []byte
	FloatArray [3]float64

	// Nested struct
	Nested NestedData

	// Map
	Metadata map[string]int
}

ComponentMixed is a comprehensive test component with all common field types. Used to verify MessagePack correctly handles the full range of Go types.

func (ComponentMixed) Name() string

type Gen ¶

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

Gen is an exhaustive generator that iterates through all possible combinations of values.

The implementation is tricky, refer to the post for details.

On each iteration of `while (!g.done())` loop, Gen generates a sequence of numbers. Internally, it remembers this sequence together with bounds the user requested:

value: 3 1 4 4 bound: 5 4 4 4

To advance to the next iteration, Gen finds the smallest sequence of values which is larger than the current one, but still satisfies all the bounds. "Smallest" means that Gen tries to increment the rightmost number.

In the above example, the last two "4"s already match the bound, so we can't increment them. However, we can increment the second number, "1", to get 3 2 4 4. This isn’t the smallest sequence though, 3 2 0 0 is be smaller. So, after incrementing the rightmost number possible, we zero the rest.

See: <https://matklad.github.io/2021/11/07/generate-all-the-things.html>

func NewGen() *Gen

func (g *Gen) Bool() bool

func (g *Gen) Done() bool

func (g *Gen) Index(length int) int

func (g *Gen) Intn(bound int) int

func (g *Gen) Range(minVal, maxVal int) int

type NestedData ¶ added in v0.10.0

type NestedData struct {
	ID    uint64
	Name  string
	Score float64
}

type OpWeights ¶ added in v0.10.0

type OpWeights = map[string]uint64

OpWeights maps operation names to their weights.

func RandOpWeights(r *rand.Rand, ops []string) OpWeights

type SimpleCommand ¶

type SimpleCommand struct {
	Value int
}

func (SimpleCommand) Name() string

type SimpleComponent ¶

type SimpleComponent struct {
	Value int
}

func (SimpleComponent) Name() string

type SimpleEvent ¶

type SimpleEvent struct {
	Value int
}

func (SimpleEvent) Name() string

type SimpleSystemEvent ¶

type SimpleSystemEvent struct {
	Value int
}

func (SimpleSystemEvent) Name() string

type SystemEventA ¶

type SystemEventA struct {
	X, Y, Z float64
}

func (SystemEventA) Name() string

type SystemEventB ¶

type SystemEventB struct {
	ID      uint64
	Label   string
	Enabled bool
}

func (SystemEventB) Name() string

type SystemEventC ¶

type SystemEventC struct {
	Values  [8]int32
	Counter uint16
}

func (SystemEventC) Name() string