test

Documentation

Overview

package test provides structures and defintions for testing

Index

• type AtomAltTest
  • func (a *AtomAltTest) NextAtom() NextAtom
• type AtomTest
  • func (a *AtomTest) NextAtom() NextAtom
• type AtomWithInterface
  • func (*AtomWithInterface) NextAtom() NextAtom
• type BlockMutation
• type CheckNext
• type Enum
  • func (i Enum) String() (ret string)
• type EnumStatement
• type FieldBlock
  • func (b *FieldBlock) Output() interface{}
• type InputBlock
• type InterfacingTerm
  • func (t *InterfacingTerm) Output() PinInterface
• type MutableBlock
  • func (n *MutableBlock) Output() *MutableBlock
• type NextAtom
• type PinInterface
• type RowBlock
  • func (b *RowBlock) Output() interface{}
• type StackBlock
• type TestNames
  • func (an *TestNames) GenerateUniqueName() string

Types

type AtomAltTest

type AtomAltTest struct {
	AtomField     string
	NextStatement NextAtom
}

func (*AtomAltTest) NextAtom

func (a *AtomAltTest) NextAtom() NextAtom

type AtomTest

type AtomTest struct {
	AtomInput     *MutableBlock
	NextStatement NextAtom
}

func (*AtomTest) NextAtom

func (a *AtomTest) NextAtom() NextAtom

type AtomWithInterface

type AtomWithInterface struct {
	Input PinInterface
}

an atom that contains an input with an interface

func (*AtomWithInterface) NextAtom

func (*AtomWithInterface) NextAtom() NextAtom

type BlockMutation

type BlockMutation struct {
	NextStatement NextAtom
}

type CheckNext

type CheckNext struct {
	NextStatement *CheckNext
}

type Enum

type Enum int

const (
	DefaultChoice Enum = iota
	AlternativeChoice
)

func (Enum) String

func (i Enum) String() (ret string)

type EnumStatement

type EnumStatement struct {
	Enum
}

type FieldBlock

type FieldBlock struct {
	Number float32
}

func (*FieldBlock) Output

func (b *FieldBlock) Output() interface{}

Output - implement a generic output

type InputBlock

type InputBlock struct {
	Value     *RowBlock      `input:"value"`
	Statement *InputBlock    `input:"statement"`
	Mutation  *BlockMutation `input:"mutation"`
}

type InterfacingTerm

type InterfacingTerm struct{}

can plug into a PinInterface Input

func (*InterfacingTerm) Output

func (t *InterfacingTerm) Output() PinInterface

type MutableBlock

type MutableBlock struct {
	Input  *MutableBlock
	Mutant *BlockMutation `input:"mutation"`
	Field  string
}

func (*MutableBlock) Output

func (n *MutableBlock) Output() *MutableBlock

Output - implement a generic output

type NextAtom

type NextAtom interface {
	NextAtom() NextAtom
}

NextAtom

type PinInterface

type PinInterface interface{ Output() PinInterface }

type RowBlock

type RowBlock struct {
	Input *RowBlock
}

see also: blockly/tests/jsunit/block_test.js setUpRowBlocks.

func (*RowBlock) Output

func (b *RowBlock) Output() interface{}

Output - implement a generic output

type StackBlock

type StackBlock struct {
	NextStatement interface{}
}

see also: blockly/tests/jsunit/block_test.js setupStackBlocks.

type TestNames

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

func (*TestNames) GenerateUniqueName

func (an *TestNames) GenerateUniqueName() string