gtr,parser/gotest: Improve benchmark output matching

pkg/gtr/event.go

@@ -43,4 +43,10 @@ type Event struct {
 	// Code coverage
 	CovPct      float64
 	CovPackages []string
+
+	// Benchmarks
+	Iterations  int64
+	NsPerOp     int64
+	BytesPerOp  int64
+	AllocsPerOp int64
 }

pkg/parser/gotest/gotest.go

@@ -14,7 +14,8 @@ import (
 )
 
 var (
-	regexBenchmark = regexp.MustCompile(`^(Benchmark[^\s]+)\s(\d+|\d+\.\d+)\s((?:[^\s]+\s[^\s]+)+)`)
+	// regexBenchmark captures 3-5 groups: benchmark name, number of times ran, ns/op (with or without decimal), B/op (optional), and allocs/op (optional).
+	regexBenchmark = regexp.MustCompile(`^(Benchmark[^ -]+)(?:-\d+\s+|\s+)(\d+)\s+(\d+|\d+\.\d+)\sns\/op(?:\s+(\d+)\sB\/op)?(?:\s+(\d+)\\sallocs/op)?`)
 	regexCoverage  = regexp.MustCompile(`^coverage:\s+(\d+|\d+\.\d+)%\s+of\s+statements(?:\sin\s(.+))?$`)
 	regexEndTest   = regexp.MustCompile(`((?:    )*)--- (PASS|FAIL|SKIP): ([^ ]+) \((\d+\.\d+)(?: seconds|s)\)`)
 	regexStatus    = regexp.MustCompile(`^(PASS|FAIL|SKIP)$`)
@@ -29,11 +30,7 @@ func Parse(r io.Reader) ([]gtr.Event, error) {
 	for s.Scan() {
 		p.parseLine(s.Text())
 	}
-	if s.Err() != nil {
+	return p.events, s.Err()
-		return nil, s.Err()
-	}
-
-	return p.events, nil
 }
 
 type parser struct {
@@ -55,10 +52,8 @@ func (p *parser) parseLine(line string) {
 		p.summary(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6])
 	} else if matches := regexCoverage.FindStringSubmatch(line); len(matches) == 3 {
 		p.coverage(matches[1], matches[2])
-	} else if matches := regexBenchmark.FindStringSubmatch(line); len(matches) == 4 {
+	} else if matches := regexBenchmark.FindStringSubmatch(line); len(matches) == 6 {
-		fields := strings.Fields(matches[3])
+		p.benchmark(matches[1], matches[2], matches[3], matches[4], matches[5])
-		//p.benchmark(matches[1], matches[2], fields)
-		p.benchmark(fields)
 	} else {
 		p.output(line)
 	}
@@ -118,10 +113,14 @@ func (p *parser) coverage(percent, packages string) {
 	})
 }
 
-func (p *parser) benchmark(fields []string) {
+func (p *parser) benchmark(name, iterations, timePerOp, bytesPerOp, allocsPerOp string) {
 	p.add(gtr.Event{
-		Type: "benchmark",
+		Type:        "benchmark",
-		Name: fields[0],
+		Name:        name,
+		Iterations:  parseInt(iterations),
+		NsPerOp:     parseInt(timePerOp),
+		BytesPerOp:  parseInt(bytesPerOp),
+		AllocsPerOp: parseInt(allocsPerOp),
 	})
 }
 
@@ -154,6 +153,12 @@ func parsePackages(pkgList string) []string {
 	return strings.Split(pkgList, ", ")
 }
 
+func parseInt(s string) int64 {
+	// ignore error
+	n, _ := strconv.ParseInt(s, 10, 64)
+	return n
+}
+
 func stripIndent(line string) (string, int) {
 	var indent int
 	for indent = 0; strings.HasPrefix(line, "    "); indent++ {

pkg/parser/gotest/gotest_test.go

@@ -1,8 +1,10 @@
 package gotest
 
 import (
+	"flag"
 	"os"
 	"path/filepath"
+	"regexp"
 	"testing"
 	"time"
 
@@ -13,6 +15,8 @@ import (
 
 const testdataRoot = "../../../testdata/"
 
+var matchTest = flag.String("match", "", "only test testdata matching this pattern")
+
 var tests = []struct {
 	in       string
 	expected []gtr.Event
@@ -328,23 +332,116 @@ var tests = []struct {
 			{Type: "status", Result: "PASS"},
 			{Type: "summary", Result: "ok", Name: "package/one", Data: "(cached)"},
 		}},
-	{"22-whitespace",
+	{"22-bench",
-		[]gtr.Event{}},
+		[]gtr.Event{
+			{Type: "output", Data: "goos: darwin"},
+			{Type: "output", Data: "goarch: amd64"},
+			{Type: "output", Data: "pkg: code.internal/state"},
+			{Type: "benchmark", Name: "BenchmarkParse", Iterations: 2000000, NsPerOp: 604},
+			{Type: "benchmark", Name: "BenchmarkReadingList", Iterations: 1000000, NsPerOp: 1425},
+			{Type: "status", Result: "PASS"},
+			{Type: "summary", Result: "ok", Name: "package/basic", Duration: 3212 * time.Millisecond},
+		}},
+	{"23-benchmem", []gtr.Event{}},
+	{"24-benchtests", []gtr.Event{}},
+	{"25-benchcount", []gtr.Event{}},
+	{"26-testbenchmultiple", []gtr.Event{}},
+	{"27-benchdecimal", []gtr.Event{}},
+	{"28-bench-1cpu", []gtr.Event{}},
+	{"29-bench-16cpu", []gtr.Event{}},
+	{"30-stdout", []gtr.Event{}},
+	{"31-syntax-error-test-binary", []gtr.Event{}},
+	{"32-failed-summary", []gtr.Event{}},
+	{"130-bench-mb", []gtr.Event{}},
+	{"131-whitespace",
+		[]gtr.Event{
+			{Type: "run_test", Name: "TestFlat"},
+			{Type: "output", Data: "printf 1"},
+			{Type: "output", Data: "printf 2"},
+			{Type: "end_test", Name: "TestFlat", Result: "PASS"},
+			{Type: "output", Data: "\twhitespace_test.go:9: log 1"},
+			{Type: "output", Data: "\twhitespace_test.go:10: log 2"},
+			{Type: "run_test", Name: "TestWithSpace"},
+			{Type: "output", Data: "no-space"},
+			{Type: "output", Data: " one-space"},
+			{Type: "output", Data: "  two-space"},
+			{Type: "output", Data: "    four-space"},
+			{Type: "output", Data: "        eight-space"},
+			{Type: "output", Data: "no-space"},
+			{Type: "end_test", Name: "TestWithSpace", Result: "PASS"},
+			{Type: "output", Data: "\twhitespace_test.go:16: no-space"},
+			{Type: "output", Data: "\twhitespace_test.go:17:  one-space"},
+			{Type: "output", Data: "\twhitespace_test.go:18:   two-space"},
+			{Type: "output", Data: "\twhitespace_test.go:19:     four-space"},
+			{Type: "output", Data: "\twhitespace_test.go:20:         eight-space"},
+			{Type: "output", Data: "\twhitespace_test.go:21: no-space"},
+			{Type: "run_test", Name: "TestWithTab"},
+			{Type: "output", Data: "no-tab"},
+			{Type: "output", Data: "\tone-tab"},
+			{Type: "output", Data: "\ttwo-tab"},
+			{Type: "end_test", Name: "TestWithTab", Result: "PASS"},
+			{Type: "output", Data: "\twhitespace_test.go:31: no-tab"},
+			{Type: "output", Data: "\twhitespace_test.go:32: \tone-tab"},
+			{Type: "output", Data: "\twhitespace_test.go:33: \t\ttwo-tab"},
+			{Type: "run_test", Name: "TestWithNewlinesFlat"},
+			{Type: "output", Data: "no-newline"},
+			{Type: "output", Data: "one-newline"},
+			{Type: "output", Data: "one-newline"},
+			{Type: "output", Data: "two-newlines"},
+			{Type: "output", Data: "two-newlines"},
+			{Type: "output", Data: "two-newlines"},
+			{Type: "end_test", Name: "TestWithNewlinesFlat", Result: "PASS"},
+			{Type: "output", Data: "        whitespace_test.go:40: no-newline"},
+			{Type: "output", Data: "        whitespace_test.go:41: one-newline"},
+			{Type: "output", Data: "                one-newline"},
+			{Type: "output", Data: "        whitespace_test.go:42: two-newlines"},
+			{Type: "output", Data: "                two-newlines"},
+			{Type: "output", Data: "                two-newlines"},
+			{Type: "run_test", Name: "TestSubTests"},
+			{Type: "run_test", Name: "TestSubTests/TestFlat"},
+			{Type: "output", Data: "printf 1"},
+			{Type: "output", Data: "printf 2"},
+			{Type: "run_test", Name: "TestSubTests/TestWithSpace"},
+			{Type: "output", Data: "no-space"},
+			{Type: "output", Data: " one-space"},
+			{Type: "output", Data: "  two-space"},
+			{Type: "output", Data: "    four-space"},
+			{Type: "output", Data: "        eight-space"},
+			{Type: "output", Data: "no-space"},
+			{Type: "run_test", Name: "TestSubTests/TestWithTab"},
+			{Type: "output", Data: "no-tab"},
+			{Type: "output", Data: "        one-tab"},
+			{Type: "output", Data: "                two-tab"},
+			{Type: "run_test", Name: "TestSubTests/TestWithNewlinesFlat"},
+			{Type: "output", Data: "no-newline"},
+			{Type: "output", Data: "one-newline"},
+			{Type: "output", Data: "one-newline"},
+			{Type: "output", Data: "two-newlines"},
+			{Type: "output", Data: "two-newlines"},
+			{Type: "output", Data: "two-newlines"},
+			{Type: "end_test", Name: "TestSubTests", Result: "PASS"},
+			{Type: "end_test", Name: "TestSubTests/TestFlat", Result: "PASS", Indent: 1},
+			{Type: "output", Data: "        whitespace_test.go:9: log 1"},
+			{Type: "output", Data: "        whitespace_test.go:10: log 2"},
+			{Type: "end_test", Name: "TestSubTests/TestWithSpace", Result: "PASS", Indent: 1},
+			{Type: "output", Data: "        whitespace_test.go:16: no-space"},
+			{Type: "output", Data: "        whitespace_test.go:17:  one-space"},
+		}},
 }
 
 func TestParse(t *testing.T) {
+	matchRegex := compileMatch(t)
 	for _, test := range tests {
 		t.Run(test.in, func(t *testing.T) {
+			if !matchRegex.MatchString(test.in) || len(test.expected) == 0 {
+				t.SkipNow()
+			}
 			testParse(t, test.in, test.expected)
 		})
 	}
 }
 
 func testParse(t *testing.T, name string, expected []gtr.Event) {
-	if len(expected) == 0 {
-		t.SkipNow()
-		return
-	}
 	f, err := os.Open(filepath.Join(testdataRoot, name+".txt"))
 	if err != nil {
 		t.Errorf("error reading %s: %v", name, err)
@@ -362,3 +459,11 @@ func testParse(t *testing.T, name string, expected []gtr.Event) {
 		t.Errorf("Parse %s returned unexpected events, diff (-got, +want):\n%v", name, diff)
 	}
 }
+
+func compileMatch(t *testing.T) *regexp.Regexp {
+	rx, err := regexp.Compile(*matchTest)
+	if err != nil {
+		t.Fatalf("Error compiling -match flag %q: %v", *matchTest, err)
+	}
+	return rx
+}