mutate

type Advice struct {
	// TestPackage and Test name the most focused covering test — the cheapest
	// place to add the missing assertion, because it already executes the line.
	TestPackage string `json:"testPackage"`
	Test        string `json:"test"`
	// Focus is how many lines that test covers in total. Smaller is closer.
	Focus int `json:"focusLines,omitempty"`
	// Duration is the test's indexed cost, so the reader knows the price of
	// iterating on it.
	Duration     time.Duration `json:"durationNanos,omitempty"`
	Prescription string        `json:"prescription"`
}

type Baseline struct {
	Version   int             `json:"version"`
	Survivors []BaselineEntry `json:"survivors"`
	// contains filtered or unexported fields
}

type BaselineEntry struct {
	ID       string `json:"id"`
	Package  string `json:"package"`
	Function string `json:"function"`
	Kind     Kind   `json:"kind"`
	Note     string `json:"note,omitempty"`
}

type ExecuteOptions struct {
	Root       string
	Tags       []string
	Env        []string
	Jobs       int
	Budget     func(plan TestPlan) time.Duration
	MinTimeout time.Duration
	Progress   func(phase string, done, total int)

	// PackageDir resolves a test package's directory. Test binaries have to run
	// there, the way `go test` does, or a test that opens testdata/ fails for
	// reasons that have nothing to do with the mutant.
	PackageDir func(importPath string) string

	// PackageOrder orders a plan's covering test packages before judging. A
	// killed mutant exits at the first package that catches it, so an order
	// informed by cost finds the kill sooner. Nil, or an order that is not a
	// permutation of the plan, falls back to lexicographic.
	PackageOrder func(plan TestPlan) []string

	// NoSchemata forces every mutant to compile its own binary. Slow, and the only
	// way to cross-check the shared-binary path.
	NoSchemata bool

	// NoHarness keeps the shared binary but spawns a process per (mutant, test
	// package) instead of switching mutants inside one; the only way to
	// cross-check the harness path.
	NoHarness bool
}

type GenerateOptions struct {
	Root     string
	Package  string
	Tags     []string
	Env      []string
	Eligible LineFilter
	Tests    func(absPath string, line int) TestPlan
}

type Kind string

type LineFilter func(absPath string, line int) bool

type Mode string

type Mutant struct {
	ID          string `json:"id"`
	Kind        Kind   `json:"kind"`
	Package     string `json:"package"`
	File        string `json:"file"`
	Line        int    `json:"line"`
	Function    string `json:"function"`
	Original    string `json:"original"`
	Replacement string `json:"replacement"`
	// contains filtered or unexported fields
}

type Outcome string

type Preflight struct {
	Failing map[string][]string
	// Ran lists the tests each package's preflight executed, pass or fail.
	// Every verdict here is evidence about test reliability, and callers that
	// keep a flake journal want the passes as much as the failures.
	Ran      map[string][]string
	Duration time.Duration
}

type Result struct {
	Mutant   Mutant  `json:"mutant"`
	Outcome  Outcome `json:"outcome"`
	Mode     Mode    `json:"mode,omitempty"`
	KilledBy string  `json:"killedBy,omitempty"`
	Detail   string  `json:"detail,omitempty"`
	// Fallback records why a schemata-capable mutant was judged on a binary of its
	// own. A silent fallback costs a compile per mutant, which is exactly the
	// slowdown the shared binary exists to remove, so the reason must surface.
	Fallback string        `json:"fallback,omitempty"`
	Tests    int           `json:"tests"`
	Duration time.Duration `json:"durationNanos"`
	// Advice is attached to survivors after judging: the covering test closest
	// to the mutated line and the input that would have killed the mutant.
	Advice *Advice `json:"advice,omitempty"`
}

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

type ScopeOptions struct {
	Graph      *graph.Graph
	Loader     *index.Loader
	BaseCommit string

	// Changes restricts mutation to lines the diff touched. Nil means the whole
	// package, which is the expensive mode and must be asked for explicitly.
	Changes []vcs.Change
}

type Score struct {
	Killed       int      `json:"killed"`
	Survived     int      `json:"survived"`
	Timeout      int      `json:"timeout"`
	NotBuilt     int      `json:"notBuilt"`
	NoCoverage   int      `json:"noCoverage"`
	Accepted     int      `json:"accepted"`
	NewSurvivors []Result `json:"newSurvivors,omitempty"`
}

type SurvivorGroup struct {
	Package   string
	Function  string
	File      string
	Survivors []Result
}

type TestPlan map[string][]string

type TestProfile func(pkg, test string) (lines int, duration time.Duration, ok bool)