Documentation
      ¶
    
    
  
    
  
    Index ¶
- Constants
 - Variables
 - func Generate(c GenConfig) int
 - func NewWrapRand(seed int64, ctl int) *wraprand
 - func ParseMaskString(arg string, tag string) (map[int]int, error)
 - func SetTunables(t TunableParams)
 - type GenConfig
 - type TunableParams
 - func (t *TunableParams) DisableDefer()
 - func (t *TunableParams) DisableMethodCalls()
 - func (t *TunableParams) DisableRecursiveCalls()
 - func (t *TunableParams) DisableReflectionCalls()
 - func (t *TunableParams) DisableTakeAddr()
 - func (t *TunableParams) LimitInputs(n int) error
 - func (t *TunableParams) LimitOutputs(n int) error
 
Constants ¶
const ( // Param not address taken. StructTfIdx = iota ArrayTfIdx MapTfIdx PointerTfIdx NumericTfIdx FloatTfIdx ComplexTfIdx ByteTfIdx StringTfIdx )
const ( // Param not address taken. SkipAll = -1 SkipNone = 0 SkipPayload = 1 )
const ( RandCtlNochecks = 0 RandCtlChecks = 1 << iota RandCtlCapture RandCtlPanic )
const CallerName = "Caller"
    const CheckerName = "Checker"
    Variables ¶
var Verbctl int = 0
    Functions ¶
func Generate ¶
Generate is the top level code generation hook for this package. Emits code according to the schema in config object 'c'.
func NewWrapRand ¶
func ParseMaskString ¶
ParseMaskString parses a string of the form K,J,...,M-N,Q-R,...,Z e.g. comma-separated integers or ranges of integers, returning the result in a form suitable for FcnMask or PkgMask fields in a Config. Here "tag" holds the mask flavor (fcn or pkg) and "arg" is the string argument to be parsed.
func SetTunables ¶
func SetTunables(t TunableParams)
SetTunables accepts a TunableParams object, checks to make sure that the settings in it are sane/logical, and applies the parameters for any subsequent calls to the Generate function. This function will issue a fatal error if any of the tunable params are incorrect/insane (for example, a 'percentage' value outside the range of 0-100).
Types ¶
type GenConfig ¶
type GenConfig struct {
	// Tag is a string prefix prepended to functions within
	// the generated code.
	Tag string
	// Output directory in to which we'll emit generated code.
	// This will be created if it does not exist.
	OutDir string
	// Packagepath prefix given to the generated code.
	PkgPath string
	// Number of test packages created within the generated corpus.
	// Each test package is essentially an independent collection
	// generated code; the point of having multiple packages is to
	// be able to get faster builds (more parallelism), and to avoid
	// the compile time issues that crop up with 'giant' packages.
	NumTestPackages int
	// Number of test function pairs within each generated test package.
	// Each pair consists of a "caller" function and  "callee" function.
	NumTestFunctions int
	// Seed for random number generator.
	Seed int64
	// Pragma is a "// go:..." compiler directive to apply to the
	// callee function as part of a generated function pair.
	Pragma string
	// Function and package mask used for minimization purposes.
	// If a given mask is non-nil, then the generator will only
	// emit code for a given func or package if its index is
	// present in the mask map.
	FcnMask map[int]int
	PkgMask map[int]int
	// Maximum number of failures to encounter before bailing out.
	MaxFail int
	// forcestackgrowth if set tells the generator to insert
	// calls to runtime.gcTestMoveStackOnNextCall at various points
	// in the generated code.
	ForceStackGrowth bool
	// Random number generator control flag (debugging)
	RandCtl int
	// Tells the generator to run "goimports" on the emitted code.
	RunGoImports bool
	// Debugging/testing hook. If set to 1, emit code that will cause the
	// build to fail; if set to 2, emit code that will cause a test to fail.
	EmitBad int
	// If EmitBad above is set, then these can be used to select the ID of
	// a specific bad func/package.
	BadPackageIdx int
	BadFuncIdx    int
}
    GenConfig contains configuration parameters relating to the mechanics of the code generation, e.g. how many packages/functions to emit, path to a directory into which we place the generated code, prefixes/packagenames for the generate code, and so on.
type TunableParams ¶
type TunableParams struct {
	// contains filtered or unexported fields
}
    TunableParams contains configuration parameters that control the flavor of code generated for a given test function. This includes things like the number of params/returns, the percentages of types (int, struct, etc) of the params/returns, and so on.
func DefaultTunables ¶
func DefaultTunables() TunableParams
func (*TunableParams) DisableDefer ¶
func (t *TunableParams) DisableDefer()
func (*TunableParams) DisableMethodCalls ¶
func (t *TunableParams) DisableMethodCalls()
func (*TunableParams) DisableRecursiveCalls ¶
func (t *TunableParams) DisableRecursiveCalls()
func (*TunableParams) DisableReflectionCalls ¶
func (t *TunableParams) DisableReflectionCalls()
func (*TunableParams) DisableTakeAddr ¶
func (t *TunableParams) DisableTakeAddr()
func (*TunableParams) LimitInputs ¶
func (t *TunableParams) LimitInputs(n int) error
func (*TunableParams) LimitOutputs ¶
func (t *TunableParams) LimitOutputs(n int) error