nhyatt/go-junit-report
1
0
Fork 0
mirror of https://github.com/jstemmer/go-junit-report.git synced 2025-04-04 20:50:14 -05:00
Code Issues Projects Releases Wiki Activity

gtr,parser/gotest: Improve benchmark output matching

Browse Source
This commit is contained in:
Joël Stemmer 2019-10-08 00:39:38 +01:00
parent a52c1b921d
commit c03c92d418
4 changed files with 135 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
pkg/gtr/event.go
View File

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

31
pkg/parser/gotest/gotest.go
View File

@ -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 nil, s.Err()
}
return p.events, nil
return p.events, s.Err()
}
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 {
fields := strings.Fields(matches[3])
//p.benchmark(matches[1], matches[2], fields)
p.benchmark(fields)
} else if matches := regexBenchmark.FindStringSubmatch(line); len(matches) == 6 {
p.benchmark(matches[1], matches[2], matches[3], matches[4], matches[5])
} 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",
Name: fields[0],
Type: "benchmark",
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++ {

117
pkg/parser/gotest/gotest_test.go
View File

@ -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",
[]gtr.Event{}},
{"22-bench",
[]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
}

0
testdata/22-whitespace.txt → testdata/131-whitespace.txt vendored
View File