// buildDiff creates a Diff for the given intermediate.
func buildDiff(test, digest string, e *expstorage.Expectations, tile *tiling.Tile, testTally map[string]tally.Tally, blamer *blame.Blamer, diffStore diff.DiffStore, paramset *paramsets.Summary, includeIgnores bool) *Diff {
ret := &Diff{
Diff: math.MaxFloat32,
Pos: nil,
Neg: nil,
}
if blamer != nil {
ret.Blame = blamer.GetBlame(test, digest, tile.Commits)
}
t := testTally[test]
if t == nil {
t = tally.Tally{}
}
ret.Pos = &DiffDigest{
Closest: digesttools.ClosestDigest(test, digest, e, t, diffStore, types.POSITIVE),
}
ret.Pos.ParamSet = paramset.Get(test, ret.Pos.Closest.Digest, includeIgnores)
ret.Neg = &DiffDigest{
Closest: digesttools.ClosestDigest(test, digest, e, t, diffStore, types.NEGATIVE),
}
ret.Neg.ParamSet = paramset.Get(test, ret.Neg.Closest.Digest, includeIgnores)
if pos, neg := ret.Pos.Closest.Diff, ret.Neg.Closest.Diff; pos < neg {
ret.Diff = pos
} else {
ret.Diff = neg
}
return ret
}
func digestFromIntermediate(test, digest string, inter *intermediate, e *expstorage.Expectations, tile *tiling.Tile, tallies *tally.Tallies, blamer *blame.Blamer, diffStore diff.DiffStore, paramset *paramsets.Summary, includeIgnores bool) *Digest {
traceTally := tallies.ByTrace()
ret := &Digest{
Test: test,
Digest: digest,
Status: e.Classification(test, digest).String(),
ParamSet: paramset.Get(test, digest, includeIgnores),
Traces: buildTraces(test, digest, inter, e, tile, traceTally),
Diff: buildDiff(test, digest, e, tile, tallies.ByTest(), blamer, diffStore, paramset, includeIgnores),
}
return ret
}
// buildDiff creates a Diff for the given intermediate.
func buildDiff(test, digest string, e *expstorage.Expectations, tile *tiling.Tile, testTally map[string]tally.Tally, blamer *blame.Blamer, diffStore diff.DiffStore, paramset *paramsets.Summary, includeIgnores bool) *Diff {
ret := &Diff{
Diff: math.MaxFloat32,
Pos: nil,
Neg: nil,
}
if blamer != nil {
ret.Blame = blamer.GetBlame(test, digest, tile.Commits)
}
t := testTally[test]
if t == nil {
t = tally.Tally{}
}
var diffVal float32 = 0
if closest := digesttools.ClosestDigest(test, digest, e, t, diffStore, types.POSITIVE); closest.Digest != "" {
ret.Pos = &DiffDigest{
Closest: closest,
}
ret.Pos.ParamSet = paramset.Get(test, ret.Pos.Closest.Digest, includeIgnores)
diffVal = closest.Diff
}
if closest := digesttools.ClosestDigest(test, digest, e, t, diffStore, types.NEGATIVE); closest.Digest != "" {
ret.Neg = &DiffDigest{
Closest: closest,
}
ret.Neg.ParamSet = paramset.Get(test, ret.Neg.Closest.Digest, includeIgnores)
if (ret.Pos == nil) || (closest.Diff < diffVal) {
diffVal = closest.Diff
}
}
ret.Diff = diffVal
return ret
}
// buildTraces returns a Trace for the given intermediate.
func buildTraces(test, digest string, inter *intermediate, e *expstorage.Expectations, tile *tiling.Tile, traceTally map[string]tally.Tally, paramset *paramsets.Summary, includeIgnores bool) Traces {
traceNames := make([]string, 0, len(inter.Traces))
for id, _ := range inter.Traces {
traceNames = append(traceNames, id)
}
ret := Traces{
TileSize: len(tile.Commits),
Traces: []Trace{},
Digests: []DigestStatus{},
ParamSet: paramset.Get(test, digest, includeIgnores),
}
sort.Strings(traceNames)
last := tile.LastCommitIndex()
y := 0
if len(traceNames) > 0 {
ret.Digests = append(ret.Digests, DigestStatus{
Digest: digest,
Status: e.Classification(test, digest).String(),
})
}
for _, id := range traceNames {
t, ok := traceTally[id]
if !ok {
continue
}
if count, ok := t[digest]; !ok || count == 0 {
continue
}
trace := inter.Traces[id].(*types.GoldenTrace)
p := Trace{
Data: []Point{},
ID: id,
Params: trace.Params(),
}
for i := last; i >= 0; i-- {
if trace.IsMissing(i) {
continue
}
// s is the status of the digest, it is either 0 for a match, or [1-8] if not.
s := 0
if trace.Values[i] != digest {
if index := digestIndex(trace.Values[i], ret.Digests); index != -1 {
s = index
} else {
if len(ret.Digests) < 9 {
d := trace.Values[i]
ret.Digests = append(ret.Digests, DigestStatus{
Digest: d,
Status: e.Classification(test, d).String(),
})
s = len(ret.Digests) - 1
} else {
s = 8
}
}
}
p.Data = append(p.Data, Point{
X: i,
Y: y,
S: s,
})
}
sort.Sort(PointSlice(p.Data))
ret.Traces = append(ret.Traces, p)
y += 1
}
return ret
}