Merge pull request #73 from brittinator/master

Adds benchmarking parser and formatter

README.md

@@ -15,15 +15,31 @@ command:
 go get -u github.com/jstemmer/go-junit-report
 ```
 
+## Contribution
+
+Create an Issue and discuss the fix or feature, then fork the package.
+Clone to github.com/jstemmer/go-junit-report.  This is necessary because go import uses this path.
+Fix or implement feature. Test and then commit change.
+Specify #Issue and describe change in the commit message.
+Create Pull Request. It can be merged by owner or administrator then.
+
+## Run Tests
+go test
+
 ## Usage
 
 go-junit-report reads the `go test` verbose output from standard in and writes
 junit compatible XML to standard out.
 
 ```bash
-go test -v 2>&1 | go-junit-report > report.xml
+go test -v -count 5 2>&1 | go-junit-report > report.xml
 ```
 
+Note that it also can parse benchmark output with `-bench` flag:
+```bash
+go test -v -bench . 2>&1 | ./go-junit-report > report.xml
+ ```
+
 [travis-badge]: https://travis-ci.org/jstemmer/go-junit-report.svg
 [travis-link]: https://travis-ci.org/jstemmer/go-junit-report
 [report-badge]: https://goreportcard.com/badge/github.com/jstemmer/go-junit-report

formatter/formatter.go

@@ -65,8 +65,9 @@ func JUnitReportXML(report *parser.Report, noXMLHeader bool, goVersion string, w
 
 	// convert Report to JUnit test suites
 	for _, pkg := range report.Packages {
+		pkg.Benchmarks = mergeBenchmarks(pkg.Benchmarks)
 		ts := JUnitTestSuite{
-			Tests:      len(pkg.Tests),
+			Tests:      len(pkg.Tests) + len(pkg.Benchmarks),
 			Failures:   0,
 			Time:       formatTime(pkg.Duration),
 			Name:       pkg.Name,
@@ -114,6 +115,18 @@ func JUnitReportXML(report *parser.Report, noXMLHeader bool, goVersion string, w
 			ts.TestCases = append(ts.TestCases, testCase)
 		}
 
+		// individual benchmarks
+		for _, benchmark := range pkg.Benchmarks {
+			benchmarkCase := JUnitTestCase{
+				Classname: classname,
+				Name:      benchmark.Name,
+				Time:      formatBenchmarkTime(benchmark.Duration),
+				Failure:   nil,
+			}
+
+			ts.TestCases = append(ts.TestCases, benchmarkCase)
+		}
+
 		suites.Suites = append(suites.Suites, ts)
 	}
 
@@ -136,6 +149,35 @@ func JUnitReportXML(report *parser.Report, noXMLHeader bool, goVersion string, w
 	return nil
 }
 
+func mergeBenchmarks(benchmarks []*parser.Benchmark) []*parser.Benchmark {
+	var merged []*parser.Benchmark
+	benchmap := make(map[string][]*parser.Benchmark)
+	for _, bm := range benchmarks {
+		if _, ok := benchmap[bm.Name]; !ok {
+			merged = append(merged, &parser.Benchmark{Name: bm.Name})
+		}
+		benchmap[bm.Name] = append(benchmap[bm.Name], bm)
+	}
+
+	for _, bm := range merged {
+		for _, b := range benchmap[bm.Name] {
+			bm.Allocs += b.Allocs
+			bm.Bytes += b.Bytes
+			bm.Duration += b.Duration
+		}
+		n := len(benchmap[bm.Name])
+		bm.Allocs /= n
+		bm.Bytes /= n
+		bm.Duration /= time.Duration(n)
+	}
+
+	return merged
+}
+
 func formatTime(d time.Duration) string {
 	return fmt.Sprintf("%.3f", d.Seconds())
 }
+
+func formatBenchmarkTime(d time.Duration) string {
+	return fmt.Sprintf("%.9f", d.Seconds())
+}

go-junit-report_test.go

@@ -919,6 +919,261 @@ var testCases = []TestCase{
 			},
 		},
 	},
+	{
+		name:       "22-bench.txt",
+		reportName: "22-report.xml",
+		report: &parser.Report{
+			Packages: []parser.Package{
+				{
+					Name:     "package/basic",
+					Duration: 3212 * time.Millisecond,
+					Time:     3212,
+					Benchmarks: []*parser.Benchmark{
+						{
+							Name:     "BenchmarkParse",
+							Duration: 604 * time.Nanosecond,
+						},
+						{
+							Name:     "BenchmarkReadingList",
+							Duration: 1425 * time.Nanosecond,
+						},
+					},
+				},
+			},
+		},
+	},
+	{
+		name:       "23-benchmem.txt",
+		reportName: "23-report.xml",
+		report: &parser.Report{
+			Packages: []parser.Package{
+				{
+					Name:     "package/one",
+					Duration: 9415 * time.Millisecond,
+					Time:     9415,
+					Benchmarks: []*parser.Benchmark{
+						{
+							Name:     "BenchmarkIpsHistoryInsert",
+							Duration: 52568 * time.Nanosecond,
+							Bytes:    24879,
+							Allocs:   494,
+						},
+						{
+							Name:     "BenchmarkIpsHistoryLookup",
+							Duration: 15208 * time.Nanosecond,
+							Bytes:    7369,
+							Allocs:   143,
+						},
+					},
+				},
+			},
+		},
+	},
+	{
+		name:       "24-benchtests.txt",
+		reportName: "24-report.xml",
+		report: &parser.Report{
+			Packages: []parser.Package{
+				{
+					Name:     "package3/baz",
+					Duration: 1382 * time.Millisecond,
+					Time:     1382,
+					Tests: []*parser.Test{
+						{
+							Name:     "TestNew",
+							Duration: 0,
+							Time:     0,
+							Result:   parser.PASS,
+							Output:   []string{},
+						},
+						{
+							Name:     "TestNew/no",
+							Duration: 0,
+							Time:     0,
+							Result:   parser.PASS,
+							Output:   []string{},
+						},
+						{
+							Name:     "TestNew/normal",
+							Duration: 0,
+							Time:     0,
+							Result:   parser.PASS,
+							Output:   []string{},
+						},
+						{
+							Name:     "TestWriteThis",
+							Duration: 0,
+							Time:     0,
+							Result:   parser.PASS,
+							Output:   []string{},
+						},
+					},
+					Benchmarks: []*parser.Benchmark{
+						{
+							Name:     "BenchmarkDeepMerge",
+							Duration: 2611 * time.Nanosecond,
+							Bytes:    1110,
+							Allocs:   16,
+						},
+						{
+							Name:     "BenchmarkNext",
+							Duration: 100 * time.Nanosecond,
+							Bytes:    100,
+							Allocs:   1,
+						},
+					},
+				},
+			},
+		},
+	},
+	{
+		name:       "25-benchcount.txt",
+		reportName: "25-report.xml",
+		report: &parser.Report{
+			Packages: []parser.Package{
+				{
+					Name:     "pkg/count",
+					Duration: 14211 * time.Millisecond,
+					Time:     14211,
+					Benchmarks: []*parser.Benchmark{
+						{
+							Name:     "BenchmarkNew",
+							Duration: 350 * time.Nanosecond,
+							Bytes:    80,
+							Allocs:   3,
+						},
+						{
+							Name:     "BenchmarkNew",
+							Duration: 357 * time.Nanosecond,
+							Bytes:    80,
+							Allocs:   3,
+						},
+						{
+							Name:     "BenchmarkNew",
+							Duration: 354 * time.Nanosecond,
+							Bytes:    80,
+							Allocs:   3,
+						},
+						{
+							Name:     "BenchmarkNew",
+							Duration: 358 * time.Nanosecond,
+							Bytes:    80,
+							Allocs:   3,
+						},
+						{
+							Name:     "BenchmarkNew",
+							Duration: 345 * time.Nanosecond,
+							Bytes:    80,
+							Allocs:   3,
+						},
+						{
+							Name:     "BenchmarkFew",
+							Duration: 100 * time.Nanosecond,
+							Bytes:    20,
+							Allocs:   1,
+						},
+						{
+							Name:     "BenchmarkFew",
+							Duration: 105 * time.Nanosecond,
+							Bytes:    20,
+							Allocs:   1,
+						},
+						{
+							Name:     "BenchmarkFew",
+							Duration: 102 * time.Nanosecond,
+							Bytes:    20,
+							Allocs:   1,
+						},
+						{
+							Name:     "BenchmarkFew",
+							Duration: 102 * time.Nanosecond,
+							Bytes:    20,
+							Allocs:   1,
+						},
+						{
+							Name:     "BenchmarkFew",
+							Duration: 102 * time.Nanosecond,
+							Bytes:    20,
+							Allocs:   1,
+						},
+					},
+				},
+			},
+		},
+	},
+	{
+		name:       "26-testbenchmultiple.txt",
+		reportName: "26-report.xml",
+		report: &parser.Report{
+			Packages: []parser.Package{
+				{
+					Name:     "mycode/common",
+					Duration: 7267 * time.Millisecond,
+					Time:     7267,
+					Benchmarks: []*parser.Benchmark{
+						{
+							Name:     "BenchmarkParse",
+							Duration: 1591 * time.Nanosecond,
+						},
+						{
+							Name:     "BenchmarkNewTask",
+							Duration: 391 * time.Nanosecond,
+						},
+					},
+				},
+				{
+					Name:     "mycode/benchmarks/channels",
+					Duration: 47084 * time.Millisecond,
+					Time:     47084,
+					Benchmarks: []*parser.Benchmark{
+						{
+							Name:     "BenchmarkFanout/Channel/10",
+							Duration: 4673 * time.Nanosecond,
+						},
+						{
+							Name:     "BenchmarkFanout/Channel/100",
+							Duration: 24965 * time.Nanosecond,
+						},
+						{
+							Name:     "BenchmarkFanout/Channel/1000",
+							Duration: 195672 * time.Nanosecond,
+						},
+						{
+							Name:     "BenchmarkFanout/Channel/10000",
+							Duration: 2410200 * time.Nanosecond,
+						},
+					},
+				},
+			},
+		},
+	},
+	{
+		name:       "27-benchdecimal.txt",
+		reportName: "27-report.xml",
+		report: &parser.Report{
+			Packages: []parser.Package{
+				{
+					Name:     "really/small",
+					Duration: 4344 * time.Millisecond,
+					Time:     4344,
+					Benchmarks: []*parser.Benchmark{
+						{
+							Name:     "BenchmarkItsy",
+							Duration: 45 * time.Nanosecond,
+						},
+						{
+							Name:     "BenchmarkTeeny",
+							Duration: 2 * time.Nanosecond,
+						},
+						{
+							Name:     "BenchmarkWeeny",
+							Duration: 0 * time.Second,
+						},
+					},
+				},
+			},
+		},
+	},
 }
 
 func TestParser(t *testing.T) {
@@ -994,6 +1249,31 @@ func TestParser(t *testing.T) {
 					t.Errorf("Test.Output (%s) ==\n%s\n, want\n%s", test.Name, testOutput, expTestOutput)
 				}
 			}
+
+			if len(pkg.Benchmarks) != len(expPkg.Benchmarks) {
+				t.Fatalf("Package Benchmarks == %d, want %d", len(pkg.Benchmarks), len(expPkg.Benchmarks))
+			}
+
+			for j, benchmark := range pkg.Benchmarks {
+				expBenchmark := expPkg.Benchmarks[j]
+
+				if benchmark.Name != expBenchmark.Name {
+					t.Errorf("Test.Name == %s, want %s", benchmark.Name, expBenchmark.Name)
+				}
+
+				if benchmark.Duration != expBenchmark.Duration {
+					t.Errorf("benchmark.Duration == %s, want %s", benchmark.Duration, expBenchmark.Duration)
+				}
+
+				if benchmark.Bytes != expBenchmark.Bytes {
+					t.Errorf("benchmark.Bytes == %d, want %d", benchmark.Bytes, expBenchmark.Bytes)
+				}
+
+				if benchmark.Allocs != expBenchmark.Allocs {
+					t.Errorf("benchmark.Allocs == %d, want %d", benchmark.Allocs, expBenchmark.Allocs)
+				}
+			}
+
 			if pkg.CoveragePct != expPkg.CoveragePct {
 				t.Errorf("Package.CoveragePct == %s, want %s", pkg.CoveragePct, expPkg.CoveragePct)
 			}

parser/parser.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"io"
 	"regexp"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -28,6 +29,7 @@ type Package struct {
 	Name        string
 	Duration    time.Duration
 	Tests       []*Test
+	Benchmarks  []*Benchmark
 	CoveragePct string
 
 	// Time is deprecated, use Duration instead.
@@ -45,12 +47,24 @@ type Test struct {
 	Time int // in milliseconds
 }
 
+// Benchmark contains the results of a single benchmark.
+type Benchmark struct {
+	Name     string
+	Duration time.Duration
+	// number of B/op
+	Bytes int
+	// number of allocs/op
+	Allocs int
+}
+
 var (
 	regexStatus   = regexp.MustCompile(`--- (PASS|FAIL|SKIP): (.+) \((\d+\.\d+)(?: seconds|s)\)`)
 	regexCoverage = regexp.MustCompile(`^coverage:\s+(\d+\.\d+)%\s+of\s+statements(?:\sin\s.+)?$`)
 	regexResult   = regexp.MustCompile(`^(ok|FAIL)\s+([^ ]+)\s+(?:(\d+\.\d+)s|\(cached\)|(\[\w+ failed]))(?:\s+coverage:\s+(\d+\.\d+)%\sof\sstatements(?:\sin\s.+)?)?$`)
-	regexOutput   = regexp.MustCompile(`(    )*\t(.*)`)
+	// regexBenchmark captures 3-5 groups: benchmark name, number of times ran, ns/op (with or without decimal), B/op (optional), and allocs/op (optional).
-	regexSummary  = regexp.MustCompile(`^(PASS|FAIL|SKIP)$`)
+	regexBenchmark = regexp.MustCompile(`^(Benchmark[^ ]+)-\d\s+(\d+)\s+(\d+|\d+\.\d+)\sns/op(?:\s+(\d+)\sB/op)?(?:\s+(\d+)\sallocs/op)?`)
+	regexOutput    = regexp.MustCompile(`(    )*\t(.*)`)
+	regexSummary   = regexp.MustCompile(`^(PASS|FAIL|SKIP)$`)
 )
 
 // Parse parses go test output from reader r and returns a report with the
@@ -64,10 +78,13 @@ func Parse(r io.Reader, pkgName string) (*Report, error) {
 	// keep track of tests we find
 	var tests []*Test
 
+	// keep track of benchmarks we find
+	var benchmarks []*Benchmark
+
 	// sum of tests' time, use this if current test has no result line (when it is compiled test)
 	var testsTime time.Duration
 
-	// current test
+	// current test or benchmark
 	var cur string
 
 	// keep track if we've already seen a summary for the current test
@@ -108,6 +125,16 @@ func Parse(r io.Reader, pkgName string) (*Report, error) {
 			// clear the current build package, so output lines won't be added to that build
 			capturedPackage = ""
 			seenSummary = false
+		} else if matches := regexBenchmark.FindStringSubmatch(line); len(matches) == 6 {
+			bytes, _ := strconv.Atoi(matches[4])
+			allocs, _ := strconv.Atoi(matches[5])
+
+			benchmarks = append(benchmarks, &Benchmark{
+				Name:     matches[1],
+				Duration: parseNanoseconds(matches[3]),
+				Bytes:    bytes,
+				Allocs:   allocs,
+			})
 		} else if strings.HasPrefix(line, "=== PAUSE ") {
 			continue
 		} else if strings.HasPrefix(line, "=== CONT ") {
@@ -137,10 +164,12 @@ func Parse(r io.Reader, pkgName string) (*Report, error) {
 			}
 
 			// all tests in this package are finished
+
 			report.Packages = append(report.Packages, Package{
 				Name:        matches[2],
 				Duration:    parseSeconds(matches[3]),
 				Tests:       tests,
+				Benchmarks:  benchmarks,
 				CoveragePct: coveragePct,
 
 				Time: int(parseSeconds(matches[3]) / time.Millisecond), // deprecated
@@ -148,6 +177,7 @@ func Parse(r io.Reader, pkgName string) (*Report, error) {
 
 			buffers[cur] = buffers[cur][0:0]
 			tests = make([]*Test, 0)
+			benchmarks = make([]*Benchmark, 0)
 			coveragePct = ""
 			cur = ""
 			testsTime = 0
@@ -206,6 +236,7 @@ func Parse(r io.Reader, pkgName string) (*Report, error) {
 			Duration:    testsTime,
 			Time:        int(testsTime / time.Millisecond),
 			Tests:       tests,
+			Benchmarks:  benchmarks,
 			CoveragePct: coveragePct,
 		})
 	}
@@ -222,6 +253,16 @@ func parseSeconds(t string) time.Duration {
 	return d
 }
 
+func parseNanoseconds(t string) time.Duration {
+	// note: if input < 1 ns precision, result will be 0s.
+	if t == "" {
+		return time.Duration(0)
+	}
+	// ignore error
+	d, _ := time.ParseDuration(t + "ns")
+	return d
+}
+
 func findTest(tests []*Test, name string) *Test {
 	for i := len(tests) - 1; i >= 0; i-- {
 		if tests[i].Name == name {

parser/parser_test.go

@@ -24,3 +24,24 @@ func TestParseSeconds(t *testing.T) {
 		}
 	}
 }
+
+func TestParseNanoseconds(t *testing.T) {
+	tests := []struct {
+		in string
+		d  time.Duration
+	}{
+		{"", 0},
+		{"0.1", 0 * time.Nanosecond},
+		{"0.9", 0 * time.Nanosecond},
+		{"4", 4 * time.Nanosecond},
+		{"5000", 5 * time.Microsecond},
+		{"2000003", 2*time.Millisecond + 3*time.Nanosecond},
+	}
+
+	for _, test := range tests {
+		d := parseNanoseconds(test.in)
+		if d != test.d {
+			t.Errorf("parseSeconds(%q) == %v, want %v\n", test.in, d, test.d)
+		}
+	}
+}

testdata/22-bench.txt

@@ -0,0 +1,7 @@
+goos: darwin
+goarch: amd64
+pkg: code.internal/state
+BenchmarkParse-8                     2000000	       604 ns/op
+BenchmarkReadingList-8               1000000	      1425 ns/op
+PASS
+ok package/basic	3.212s

testdata/22-report.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+	<testsuite tests="2" failures="0" time="3.212" name="package/basic">
+		<properties>
+			<property name="go.version" value="1.0"></property>
+		</properties>
+		<testcase classname="basic" name="BenchmarkParse" time="0.000000604"></testcase>
+		<testcase classname="basic" name="BenchmarkReadingList" time="0.000001425"></testcase>
+	</testsuite>
+</testsuites>

testdata/23-benchmem.txt

@@ -0,0 +1,7 @@
+goos: darwin
+goarch: amd64
+pkg: code.internal/state
+BenchmarkIpsHistoryInsert-8 30000	52568 ns/op	24879 B/op	494 allocs/op
+BenchmarkIpsHistoryLookup-8 100000	15208 ns/op	7369 B/op	143 allocs/op
+PASS
+ok package/one	9.415s

testdata/23-report.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+	<testsuite tests="2" failures="0" time="9.415" name="package/one">
+		<properties>
+			<property name="go.version" value="1.0"></property>
+		</properties>
+		<testcase classname="one" name="BenchmarkIpsHistoryInsert" time="0.000052568"></testcase>
+		<testcase classname="one" name="BenchmarkIpsHistoryLookup" time="0.000015208"></testcase>
+	</testsuite>
+</testsuites>

testdata/24-benchtests.txt

@@ -0,0 +1,15 @@
+=== RUN   TestNew
+=== RUN   TestNew/no
+=== RUN   TestNew/normal
+--- PASS: TestNew (0.00s)
+    --- PASS: TestNew/no (0.00s)
+    --- PASS: TestNew/normal (0.00s)
+=== RUN   TestWriteThis
+--- PASS: TestWriteThis (0.00s)
+goos: darwin
+goarch: amd64
+pkg: package3/baz
+BenchmarkDeepMerge-8      500000       2611 ns/op     1110 B/op       16 allocs/op
+BenchmarkNext-8           500000       100 ns/op      100 B/op        1 allocs/op
+PASS
+ok   package3/baz 1.382s

testdata/24-report.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+	<testsuite tests="6" failures="0" time="1.382" name="package3/baz">
+		<properties>
+			<property name="go.version" value="1.0"></property>
+		</properties>
+		<testcase classname="baz" name="TestNew" time="0.000"></testcase>
+		<testcase classname="baz" name="TestNew/no" time="0.000"></testcase>
+		<testcase classname="baz" name="TestNew/normal" time="0.000"></testcase>
+		<testcase classname="baz" name="TestWriteThis" time="0.000"></testcase>
+		<testcase classname="baz" name="BenchmarkDeepMerge" time="0.000002611"></testcase>
+		<testcase classname="baz" name="BenchmarkNext" time="0.000000100"></testcase>
+	</testsuite>
+</testsuites>

testdata/25-benchcount.txt

@@ -0,0 +1,12 @@
+BenchmarkNew-8   	 5000000	       350 ns/op	      80 B/op	       3 allocs/op
+BenchmarkNew-8   	 5000000	       357 ns/op	      80 B/op	       3 allocs/op
+BenchmarkNew-8   	 5000000	       354 ns/op	      80 B/op	       3 allocs/op
+BenchmarkNew-8   	 5000000	       358 ns/op	      80 B/op	       3 allocs/op
+BenchmarkNew-8   	 5000000	       345 ns/op	      80 B/op	       3 allocs/op
+BenchmarkFew-8   	 5000000	       100 ns/op	      20 B/op	       1 allocs/op
+BenchmarkFew-8   	 5000000	       105 ns/op	      20 B/op	       1 allocs/op
+BenchmarkFew-8   	 5000000	       102 ns/op	      20 B/op	       1 allocs/op
+BenchmarkFew-8   	 5000000	       102 ns/op	      20 B/op	       1 allocs/op
+BenchmarkFew-8   	 5000000	       102 ns/op	      20 B/op	       1 allocs/op
+PASS
+ok  	pkg/count	14.211s

testdata/25-report.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+	<testsuite tests="2" failures="0" time="14.211" name="pkg/count">
+		<properties>
+			<property name="go.version" value="1.0"></property>
+		</properties>
+		<testcase classname="count" name="BenchmarkNew" time="0.000000352"></testcase>
+		<testcase classname="count" name="BenchmarkFew" time="0.000000102"></testcase>
+	</testsuite>
+</testsuites>

testdata/26-report.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+	<testsuite tests="2" failures="0" time="7.267" name="mycode/common">
+		<properties>
+			<property name="go.version" value="1.0"></property>
+		</properties>
+		<testcase classname="common" name="BenchmarkParse" time="0.000001591"></testcase>
+		<testcase classname="common" name="BenchmarkNewTask" time="0.000000391"></testcase>
+	</testsuite>
+	<testsuite tests="4" failures="0" time="47.084" name="mycode/benchmarks/channels">
+		<properties>
+			<property name="go.version" value="1.0"></property>
+		</properties>
+		<testcase classname="channels" name="BenchmarkFanout/Channel/10" time="0.000004673"></testcase>
+		<testcase classname="channels" name="BenchmarkFanout/Channel/100" time="0.000024965"></testcase>
+		<testcase classname="channels" name="BenchmarkFanout/Channel/1000" time="0.000195672"></testcase>
+		<testcase classname="channels" name="BenchmarkFanout/Channel/10000" time="0.002410200"></testcase>
+	</testsuite>
+</testsuites>

testdata/26-testbenchmultiple.txt

@@ -0,0 +1,12 @@
+pkg: mycode/common
+BenchmarkParse-8                   	 1000000	      1591 ns/op
+BenchmarkNewTask-8                 	 3000000	       391 ns/op
+PASS
+ok  	mycode/common	7.267s
+pkg: mycode/benchmarks/channels
+BenchmarkFanout/Channel/10-8         	  500000	      4673 ns/op
+BenchmarkFanout/Channel/100-8        	   50000	     24965 ns/op
+BenchmarkFanout/Channel/1000-8       	   10000	    195672 ns/op
+BenchmarkFanout/Channel/10000-8      	     500	   2410200 ns/op
+PASS
+ok  	mycode/benchmarks/channels	47.084s

testdata/27-benchdecimal.txt

@@ -0,0 +1,8 @@
+goos: darwin
+goarch: amd64
+pkg: really/small
+BenchmarkItsy-8    	  30000000	         45.7 ns/op
+BenchmarkTeeny-8      1000000000	         2.12 ns/op
+BenchmarkWeeny-8      2000000000	         0.26 ns/op
+PASS
+ok really/small	4.344s

testdata/27-report.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+	<testsuite tests="3" failures="0" time="4.344" name="really/small">
+		<properties>
+			<property name="go.version" value="1.0"></property>
+		</properties>
+		<testcase classname="small" name="BenchmarkItsy" time="0.000000045"></testcase>
+		<testcase classname="small" name="BenchmarkTeeny" time="0.000000002"></testcase>
+		<testcase classname="small" name="BenchmarkWeeny" time="0.000000000"></testcase>
+	</testsuite>
+</testsuites>