Coverage: Improve uncovered visualizations

tests/regres/cov/coverage_test.go

@@ -334,8 +334,8 @@ func coverage(file string, spans ...cov.Span) *cov.Coverage {
 	return &cov.Coverage{
 		[]cov.File{
 			cov.File{
-				Path:  file,
-				Spans: spans,
+				Path:    file,
+				Covered: spans,
 			},
 		},
 	}

tests/regres/cov/import.go

@@ -18,7 +18,6 @@ import (
 	"bytes"
 	"encoding/binary"
 	"encoding/json"
-	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -28,60 +27,20 @@ import (
 	"../llvm"
 )
 
-// Location describes a single line-column position in a source file.
-type Location struct {
-	Line, Column int
+var ignorePaths = map[string]bool{
+	"src/Common":   true,
+	"src/Main":     true,
+	"src/OpenGL":   true,
+	"src/Renderer": true,
+	"src/Shader":   true,
+	"src/System":   true,
 }
 
-func (l Location) String() string {
-	return fmt.Sprintf("%v:%v", l.Line, l.Column)
-}
-
-// Compare returns -1 if l comes before o, 1 if l comes after o, otherwise 0.
-func (l Location) Compare(o Location) int {
-	switch {
-	case l.Line < o.Line:
-		return -1
-	case l.Line > o.Line:
-		return 1
-	}
-	return 0
-}
-
-// Before returns true if l comes before o.
-func (l Location) Before(o Location) bool { return l.Compare(o) == -1 }
-
-// Span describes a start and end interval in a source file.
-type Span struct {
-	Start, End Location
-}
-
-func (s Span) String() string {
-	return fmt.Sprintf("%v-%v", s.Start, s.End)
-}
-
-// Compare returns -1 if l comes before o, 1 if l comes after o, otherwise 0.
-func (s Span) Compare(o Span) int {
-	switch {
-	case s.Start.Before(o.Start):
-		return -1
-	case o.Start.Before(s.Start):
-		return 1
-	case s.End.Before(o.End):
-		return -1
-	case o.End.Before(s.End):
-		return 1
-	}
-	return 0
-}
-
-// Before returns true if span s comes before o.
-func (s Span) Before(o Span) bool { return s.Compare(o) == -1 }
-
 // File describes the coverage spans in a single source file.
 type File struct {
-	Path  string
-	Spans []Span
+	Path      string
+	Covered   SpanList // Spans with coverage
+	Uncovered SpanList // Compiled spans without coverage
 }
 
 // Coverage describes the coverage spans for all the source files for a single
@@ -148,9 +107,45 @@ func (e Env) Import(profrawPath string) (*Coverage, error) {
 	if err != nil {
 		return nil, cause.Wrap(err, "Couldn't process turbo-cov output")
 	}
+
+	// Gather all the source files to include them even if there is no coverage
+	// information produced for these files. This highlights files that aren't
+	// even compiled.
+	allFiles := map[string]struct{}{}
+	for _, file := range cov.Files {
+		allFiles[file.Path] = struct{}{}
+	}
+	filepath.Walk(filepath.Join(e.RootDir, "src"), func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		rel, err := filepath.Rel(e.RootDir, path)
+		if err != nil || ignorePaths[rel] {
+			return filepath.SkipDir
+		}
+		if !info.IsDir() {
+			switch filepath.Ext(path) {
+			case ".h", ".c", ".cc", ".cpp", ".hpp":
+				if _, seen := allFiles[rel]; !seen {
+					cov.Files = append(cov.Files, File{Path: rel})
+				}
+			}
+		}
+		return nil
+	})
+
 	return cov, nil
 }
 
+func appendSpan(spans []Span, span Span) []Span {
+	if c := len(spans); c > 0 && spans[c-1].End == span.Start {
+		spans[c-1].End = span.End
+	} else {
+		spans = append(spans, span)
+	}
+	return spans
+}
+
 // https://clang.llvm.org/docs/SourceBasedCodeCoverage.html
 // https://stackoverflow.com/a/56792192
 func (e Env) parseCov(raw []byte) (*Coverage, error) {
@@ -189,16 +184,13 @@ func (e Env) parseCov(raw []byte) (*Coverage, error) {
 		for sIdx := 0; sIdx+1 < len(f.Segments); sIdx++ {
 			start := Location{(int)(f.Segments[sIdx][0].(float64)), (int)(f.Segments[sIdx][1].(float64))}
 			end := Location{(int)(f.Segments[sIdx+1][0].(float64)), (int)(f.Segments[sIdx+1][1].(float64))}
-			covered := f.Segments[sIdx][2].(float64) != 0
-			if covered {
-				if c := len(file.Spans); c > 0 && file.Spans[c-1].End == start {
-					file.Spans[c-1].End = end
-				} else {
-					file.Spans = append(file.Spans, Span{start, end})
-				}
+			if covered := f.Segments[sIdx][2].(float64) != 0; covered {
+				file.Covered.Add(Span{start, end})
+			} else {
+				file.Uncovered.Add(Span{start, end})
 			}
 		}
-		if len(file.Spans) > 0 {
+		if len(file.Covered) > 0 {
 			c.Files = append(c.Files, file)
 		}
 	}
@@ -257,16 +249,16 @@ func (e Env) parseTurboCov(data []byte) (*Coverage, error) {
 		for sIdx := 0; sIdx+1 < len(segments); sIdx++ {
 			start := segments[sIdx].location
 			end := segments[sIdx+1].location
-			if segments[sIdx].count > 0 {
-				if c := len(file.Spans); c > 0 && file.Spans[c-1].End == start {
-					file.Spans[c-1].End = end
+			if segments[sIdx].covered {
+				if segments[sIdx].count > 0 {
+					file.Covered.Add(Span{start, end})
 				} else {
-					file.Spans = append(file.Spans, Span{start, end})
+					file.Uncovered.Add(Span{start, end})
 				}
 			}
 		}
 
-		if len(file.Spans) > 0 {
+		if len(file.Covered) > 0 {
 			c.Files = append(c.Files, file)
 		}
 	}

tests/regres/cov/parser.go → tests/regres/cov/serialization.go

@@ -50,6 +50,11 @@ func (t *Tree) JSON(revision string) string {
 	sb := &strings.Builder{}
 	sb.WriteString(`{`)
 
+	spansByID := map[SpanID]Span{}
+	for span, id := range t.spans {
+		spansByID[id] = span
+	}
+
 	// write the revision
 	sb.WriteString(`"r":"` + revision + `"`)
 
@@ -75,7 +80,7 @@ func (t *Tree) JSON(revision string) string {
 
 	// write the files
 	sb.WriteString(`,"f":`)
-	t.writeFilesJSON(sb)
+	t.writeFilesJSON(spansByID, sb)
 
 	sb.WriteString(`}`)
 	return sb.String()
@@ -125,7 +130,13 @@ func (t *Tree) writeSpansJSON(sb *strings.Builder) {
 	sb.WriteString(`]`)
 }
 
-func (t *Tree) writeFilesJSON(sb *strings.Builder) {
+func (t *Tree) writeSpanJSON(span Span, sb *strings.Builder) {
+	sb.WriteString(fmt.Sprintf("[%v,%v,%v,%v]",
+		span.Start.Line, span.Start.Column,
+		span.End.Line, span.End.Column))
+}
+
+func (t *Tree) writeFilesJSON(spansByID map[SpanID]Span, sb *strings.Builder) {
 	paths := make([]string, 0, len(t.files))
 	for path := range t.files {
 		paths = append(paths, path)
@@ -135,6 +146,20 @@ func (t *Tree) writeFilesJSON(sb *strings.Builder) {
 	sb.WriteString(`{`)
 	for i, path := range paths {
 		file := t.files[path]
+
+		uncovered := append(SpanList{}, file.allSpans...)
+		file.tcm.traverse(func(tc *TestCoverage) {
+			for id := range tc.Spans {
+				uncovered.Remove(spansByID[id])
+			}
+		})
+
+		percentage := 0.0
+		if totalLines := file.allSpans.NumLines(); totalLines > 0 {
+			uncoveredLines := uncovered.NumLines()
+			percentage = 1.0 - (float64(uncoveredLines) / float64(totalLines))
+		}
+
 		if i > 0 {
 			sb.WriteString(`,`)
 		}
@@ -142,8 +167,12 @@ func (t *Tree) writeFilesJSON(sb *strings.Builder) {
 		sb.WriteString(path)
 		sb.WriteString(`":`)
 		sb.WriteString(`{`)
-		sb.WriteString(`"g":`)
+		sb.WriteString(`"p":`)
+		sb.WriteString(fmt.Sprintf("%v", percentage))
+		sb.WriteString(`,"g":`)
 		t.writeSpanGroupsJSON(file.spangroups, sb)
+		sb.WriteString(`,"u":`)
+		t.writeUncoveredJSON(file, uncovered, sb)
 		sb.WriteString(`,"c":`)
 		t.writeCoverageMapJSON(file.tcm, sb)
 		sb.WriteString(`}`)
@@ -190,6 +219,17 @@ func (t *Tree) writeSpanGroupJSON(group SpanGroup, sb *strings.Builder) {
 	sb.WriteString(`}`)
 }
 
+func (t *Tree) writeUncoveredJSON(tf *treeFile, uncovered SpanList, sb *strings.Builder) {
+	sb.WriteString(`[`)
+	for i, span := range uncovered {
+		if i > 0 {
+			sb.WriteString(`,`)
+		}
+		t.writeSpanJSON(span, sb)
+	}
+	sb.WriteString(`]`)
+}
+
 func (t *Tree) writeCoverageMapJSON(c TestCoverageMap, sb *strings.Builder) {
 	ids := make([]TestIndex, 0, len(c))
 	for id := range c {
@@ -326,10 +366,14 @@ func (p *parser) parseFile() *treeFile {
 	if p.peek() == '{' {
 		p.dict(func(key string) {
 			switch key {
+			case "p":
+				p.double()
 			case "g":
 				file.spangroups = p.parseSpanGroups()
 			case "c":
 				p.parseCoverageMap(file.tcm)
+			case "u":
+				p.parseUncovered(file)
 			default:
 				p.fail("Unknown file key: '%s'", key)
 			}
@@ -371,6 +415,12 @@ func (p *parser) parseCoverageMap(tcm TestCoverageMap) {
 	})
 }
 
+func (p *parser) parseUncovered(tf *treeFile) {
+	p.array(func(int) {
+		tf.allSpans.Add(p.parseSpan())
+	})
+}
+
 func (p *parser) parseCoverage(tc *TestCoverage) {
 	p.dict(func(key string) {
 		switch key {
@@ -505,6 +555,26 @@ func (p *parser) integer() int {
 	return i
 }
 
+func (p *parser) double() float64 {
+	sb := strings.Builder{}
+	for {
+		if c := p.peek(); c != '.' && (c < '0' || c > '9') {
+			break
+		}
+		sb.WriteByte(p.next())
+	}
+	if sb.Len() == 0 {
+		p.fail("Expected double, got '%c'", p.peek())
+		return 0
+	}
+	f, err := strconv.ParseFloat(sb.String(), 64)
+	if err != nil {
+		p.fail("Failed to parse double: %v", err)
+		return 0
+	}
+	return f
+}
+
 func (p *parser) fail(msg string, args ...interface{}) {
 	if p.err == nil {
 		msg = fmt.Sprintf(msg, args...)

tests/regres/cov/span.go

+// Copyright 2020 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cov
+
+import (
+	"fmt"
+	"sort"
+)
+
+// Location describes a single line-column position in a source file.
+type Location struct {
+	Line, Column int
+}
+
+func (l Location) String() string {
+	return fmt.Sprintf("%v:%v", l.Line, l.Column)
+}
+
+// Compare returns -1 if l comes before o, 1 if l comes after o, otherwise 0.
+func (l Location) Compare(o Location) int {
+	switch {
+	case l.Line < o.Line:
+		return -1
+	case l.Line > o.Line:
+		return 1
+	case l.Column < o.Column:
+		return -1
+	case l.Column > o.Column:
+		return 1
+	}
+	return 0
+}
+
+// Before returns true if l comes before o.
+func (l Location) Before(o Location) bool { return l.Compare(o) == -1 }
+
+// After returns true if l comes after o.
+func (l Location) After(o Location) bool { return l.Compare(o) == 1 }
+
+// Span describes a start and end interval in a source file.
+type Span struct {
+	Start, End Location
+}
+
+func (s Span) String() string {
+	return fmt.Sprintf("%v-%v", s.Start, s.End)
+}
+
+// Compare returns -1 if l comes before o, 1 if l comes after o, otherwise 0.
+func (s Span) Compare(o Span) int {
+	switch {
+	case s.Start.Before(o.Start):
+		return -1
+	case o.Start.Before(s.Start):
+		return 1
+	case s.End.Before(o.End):
+		return -1
+	case o.End.Before(s.End):
+		return 1
+	}
+	return 0
+}
+
+// Before returns true if span s comes before o.
+func (s Span) Before(o Span) bool { return s.Compare(o) == -1 }
+
+// SpanList is a sorted list of spans. Use SpanList.Add() to insert new spans.
+type SpanList []Span
+
+// Add adds the Span to the SpanList, merging and expanding overlapping spans.
+func (l *SpanList) Add(s Span) {
+	//          [===]
+	//  [0] [1]                | idxStart: 2 |  idxEnd: 2
+	//                [0] [1]  | idxStart: 0 |  idxEnd: 0
+	// [ 0 ] [ 1 ] [ 2 ] [ 3 ] | idxStart: 1 |  idxEnd: 2
+	// [0]  [1]  [2]  [3]  [4] | idxStart: 2 |  idxEnd: 2
+	idxStart := sort.Search(len(*l), func(i int) bool { return (*l)[i].End.Compare(s.Start) >= 0 })
+	idxEnd := sort.Search(len(*l), func(i int) bool { return (*l)[i].Start.Compare(s.End) > 0 })
+
+	if idxStart < idxEnd {
+		if first := (*l)[idxStart]; first.Start.Before(s.Start) {
+			s.Start = first.Start
+		}
+		if last := (*l)[idxEnd-1]; last.End.After(s.End) {
+			s.End = last.End
+		}
+	}
+
+	merged := append(SpanList{}, (*l)[:idxStart]...)
+	merged = append(merged, s)
+	merged = append(merged, (*l)[idxEnd:]...)
+	*l = merged
+}
+
+// Remove cuts out the Span from the SpanList, removing and trimming overlapping
+// spans.
+func (l *SpanList) Remove(s Span) {
+	if s.Start == s.End {
+		return // zero length == no split.
+	}
+
+	//          [===]
+	//  [0] [1]                | idxStart: 2 |  idxEnd: 2
+	//                [0] [1]  | idxStart: 0 |  idxEnd: 0
+	// [ 0 ] [ 1 ] [ 2 ] [ 3 ] | idxStart: 1 |  idxEnd: 2
+	// [0]  [1]  [2]  [3]  [4] | idxStart: 2 |  idxEnd: 2
+	idxStart := sort.Search(len(*l), func(i int) bool { return (*l)[i].End.Compare(s.Start) > 0 })
+	idxEnd := sort.Search(len(*l), func(i int) bool { return (*l)[i].Start.Compare(s.End) >= 0 })
+
+	merged := append(SpanList{}, (*l)[:idxStart]...)
+
+	if idxStart < idxEnd {
+		first, last := (*l)[idxStart], (*l)[idxEnd-1]
+		if first.Start.Compare(s.Start) < 0 {
+			merged = append(merged, Span{first.Start, s.Start})
+		}
+		if last.End.Compare(s.End) > 0 {
+			merged = append(merged, Span{s.End, last.End})
+		}
+	}
+
+	merged = append(merged, (*l)[idxEnd:]...)
+	*l = merged
+}
+
+// Compare returns -1 if l comes before o, 1 if l comes after o, otherwise 0.
+func (l SpanList) Compare(o SpanList) int {
+	switch {
+	case len(l) < len(o):
+		return -1
+	case len(l) > len(o):
+		return 1
+	}
+	for i, a := range l {
+		switch a.Compare(o[i]) {
+		case -1:
+			return -1
+		case 1:
+			return 1
+		}
+	}
+	return 0
+}
+
+// NumLines returns the total number of lines covered by all spans in the list.
+func (l SpanList) NumLines() int {
+	seen := map[int]struct{}{}
+	for _, span := range l {
+		for s := span.Start.Line; s <= span.End.Line; s++ {
+			if _, ok := seen[s]; !ok {
+				seen[s] = struct{}{}
+			}
+		}
+	}
+	return len(seen)
+}

tests/regres/cov/span_test.go

+// Copyright 2020 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cov_test
+
+import (
+	"reflect"
+	"testing"
+
+	cov "."
+)
+
+func TestSpanListAddNoMerge(t *testing.T) {
+	l := cov.SpanList{}
+	l.Add(span(3, 1, 3, 5))
+	checkSpanList(t, l, span(3, 1, 3, 5))
+
+	l.Add(span(4, 1, 4, 5))
+	checkSpanList(t, l, span(3, 1, 3, 5), span(4, 1, 4, 5))
+
+	l.Add(span(2, 1, 2, 5))
+	checkSpanList(t, l, span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+}
+
+func TestSpanListAddExpand(t *testing.T) {
+	l := cov.SpanList{span(1, 1, 1, 5), span(5, 4, 5, 7), span(9, 1, 9, 5)}
+
+	// Expand front (column)
+	l.Add(span(5, 1, 5, 5))
+	checkSpanList(t, l, span(1, 1, 1, 5), span(5, 1, 5, 7), span(9, 1, 9, 5))
+
+	// Expand back (column)
+	l.Add(span(5, 5, 5, 9))
+	checkSpanList(t, l, span(1, 1, 1, 5), span(5, 1, 5, 9), span(9, 1, 9, 5))
+
+	// Expand front (line)
+	l.Add(span(4, 3, 5, 2))
+	checkSpanList(t, l, span(1, 1, 1, 5), span(4, 3, 5, 9), span(9, 1, 9, 5))
+
+	// Expand back (line)
+	l.Add(span(5, 4, 6, 3))
+	checkSpanList(t, l, span(1, 1, 1, 5), span(4, 3, 6, 3), span(9, 1, 9, 5))
+
+	// Expand front (touching)
+	l.Add(span(4, 2, 4, 3))
+	checkSpanList(t, l, span(1, 1, 1, 5), span(4, 2, 6, 3), span(9, 1, 9, 5))
+
+	// Expand back (touching)
+	l.Add(span(6, 3, 6, 4))
+	checkSpanList(t, l, span(1, 1, 1, 5), span(4, 2, 6, 4), span(9, 1, 9, 5))
+}
+
+func TestSpanListAddMergeOverlap(t *testing.T) {
+	l := cov.SpanList{span(1, 1, 1, 5), span(5, 4, 5, 7), span(9, 1, 9, 5)}
+
+	l.Add(span(1, 3, 5, 6))
+	checkSpanList(t, l, span(1, 1, 5, 7), span(9, 1, 9, 5))
+
+	l.Add(span(5, 5, 9, 3))
+	checkSpanList(t, l, span(1, 1, 9, 5))
+}
+
+func TestSpanListAddMergeTouching(t *testing.T) {
+	l := cov.SpanList{span(1, 1, 1, 5), span(5, 4, 5, 7), span(9, 1, 9, 5)}
+
+	l.Add(span(1, 5, 9, 1))
+	checkSpanList(t, l, span(1, 1, 9, 5))
+}
+
+func TestSpanListRemoveNothing(t *testing.T) {
+	l := cov.SpanList{span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5)}
+
+	l.Remove(span(1, 1, 2, 1))
+	checkSpanList(t, l, span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(2, 5, 3, 1))
+	checkSpanList(t, l, span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(3, 5, 4, 1))
+	checkSpanList(t, l, span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(4, 5, 10, 10))
+	checkSpanList(t, l, span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+}
+
+func TestSpanListRemoveWhole(t *testing.T) {
+	l := cov.SpanList{span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5)}
+
+	l.Remove(span(3, 1, 3, 5))
+	checkSpanList(t, l, span(2, 1, 2, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(1, 1, 3, 3))
+	checkSpanList(t, l, span(4, 1, 4, 5))
+
+	l.Remove(span(3, 1, 4, 5))
+	checkSpanList(t, l)
+}
+
+func TestSpanListRemoveZeroLength(t *testing.T) {
+	l := cov.SpanList{span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5)}
+
+	l.Remove(span(3, 1, 3, 1))
+	checkSpanList(t, l, span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(3, 5, 3, 5))
+	checkSpanList(t, l, span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+}
+
+func TestSpanListRemoveTrim(t *testing.T) {
+	l := cov.SpanList{span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5)}
+
+	l.Remove(span(2, 1, 2, 2))
+	checkSpanList(t, l, span(2, 2, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(2, 4, 2, 5))
+	checkSpanList(t, l, span(2, 2, 2, 4), span(3, 1, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(2, 5, 3, 2))
+	checkSpanList(t, l, span(2, 2, 2, 4), span(3, 2, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(3, 4, 3, 5))
+	checkSpanList(t, l, span(2, 2, 2, 4), span(3, 2, 3, 4), span(4, 1, 4, 5))
+
+	l.Remove(span(4, 1, 4, 2))
+	checkSpanList(t, l, span(2, 2, 2, 4), span(3, 2, 3, 4), span(4, 2, 4, 5))
+
+	l.Remove(span(4, 4, 4, 5))
+	checkSpanList(t, l, span(2, 2, 2, 4), span(3, 2, 3, 4), span(4, 2, 4, 4))
+}
+
+func TestSpanListRemoveSplit(t *testing.T) {
+	l := cov.SpanList{span(2, 1, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5)}
+
+	l.Remove(span(2, 2, 2, 3))
+	checkSpanList(t, l, span(2, 1, 2, 2), span(2, 3, 2, 5), span(3, 1, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(3, 2, 3, 4))
+	checkSpanList(t, l, span(2, 1, 2, 2), span(2, 3, 2, 5), span(3, 1, 3, 2), span(3, 4, 3, 5), span(4, 1, 4, 5))
+
+	l.Remove(span(4, 2, 4, 2)) // zero length == no split
+	checkSpanList(t, l, span(2, 1, 2, 2), span(2, 3, 2, 5), span(3, 1, 3, 2), span(3, 4, 3, 5), span(4, 1, 4, 5))
+}
+
+func span(startLine, startColumn, endLine, endColumn int) cov.Span {
+	return cov.Span{
+		Start: cov.Location{Line: startLine, Column: startColumn},
+		End:   cov.Location{Line: endLine, Column: endColumn},
+	}
+}
+
+func checkSpanList(t *testing.T, got cov.SpanList, expect ...cov.Span) {
+	if expect == nil {
+		expect = cov.SpanList{}
+	}
+	if !reflect.DeepEqual(got, cov.SpanList(expect)) {
+		t.Errorf("SpanList not as expected.\nGot:\n%v\nExpect:\n%v", got, cov.SpanList(expect))
+	}
+}

tests/regres/cov/tree.go

@@ -23,6 +23,7 @@ import (
 type treeFile struct {
 	tcm        TestCoverageMap
 	spangroups map[SpanGroupID]SpanGroup
+	allSpans   SpanList
 }
 
 func newTreeFile() *treeFile {
@@ -52,28 +53,6 @@ func (t *Tree) init() {
 	}
 }
 
-// SpanList is a list of Spans
-type SpanList []Span
-
-// Compare returns -1 if l comes before o, 1 if l comes after o, otherwise 0.
-func (l SpanList) Compare(o SpanList) int {
-	switch {
-	case len(l) < len(o):
-		return -1
-	case len(l) > len(o):
-		return 1
-	}
-	for i, a := range l {
-		switch a.Compare(o[i]) {
-		case -1:
-			return -1
-		case 1:
-			return 1
-		}
-	}
-	return 0
-}
-
 // Spans returns all the spans used by the tree
 func (t *Tree) Spans() SpanList {
 	out := make(SpanList, len(t.spans))
@@ -109,7 +88,7 @@ func (t *Tree) index(path Path) []indexedTest {
 	return out
 }
 
-func (t *Tree) addSpans(spans []Span) SpanSet {
+func (t *Tree) addSpans(spans SpanList) SpanSet {
 	out := make(SpanSet, len(spans))
 	for _, s := range spans {
 		id, ok := t.spans[s]
@@ -138,8 +117,15 @@ nextFile:
 			t.files[file.Path] = tf
 		}
 
+		for _, span := range file.Covered {
+			tf.allSpans.Add(span)
+		}
+		for _, span := range file.Uncovered {
+			tf.allSpans.Add(span)
+		}
+
 		// Add all the spans to the map, get the span ids
-		spans := t.addSpans(file.Spans)
+		spans := t.addSpans(file.Covered)
 
 		// Starting from the test root, walk down the test tree.
 		tcm, test := tf.tcm, t.testRoot