testutils

type AnotherEvent ¶

type AnotherEvent struct {
	Data string
}

func (AnotherEvent) 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 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 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

type WeightedOp ¶

type WeightedOp interface {
	~uint8 | ~uint16 | ~uint32 | ~int
}

WeightedOp is a constraint for operation types that use their value as the weight.