benchmark_test.go

     1  // Copyright 2013 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package testing_test
     6  
     7  import (
     8  	"bytes"
     9  	"runtime"
    10  	"sort"
    11  	"strings"
    12  	"sync/atomic"
    13  	"testing"
    14  	"text/template"
    15  	"time"
    16  )
    17  
    18  var prettyPrintTests = []struct {
    19  	v        float64
    20  	expected string
    21  }{
    22  	{0, "         0 x"},
    23  	{1234.1, "      1234 x"},
    24  	{-1234.1, "     -1234 x"},
    25  	{999.950001, "      1000 x"},
    26  	{999.949999, "       999.9 x"},
    27  	{99.9950001, "       100.0 x"},
    28  	{99.9949999, "        99.99 x"},
    29  	{-99.9949999, "       -99.99 x"},
    30  	{0.000999950001, "         0.001000 x"},
    31  	{0.000999949999, "         0.0009999 x"}, // smallest case
    32  	{0.0000999949999, "         0.0001000 x"},
    33  }
    34  
    35  func TestPrettyPrint(t *testing.T) {
    36  	for _, tt := range prettyPrintTests {
    37  		buf := new(strings.Builder)
    38  		testing.PrettyPrint(buf, tt.v, "x")
    39  		if tt.expected != buf.String() {
    40  			t.Errorf("prettyPrint(%v): expected %q, actual %q", tt.v, tt.expected, buf.String())
    41  		}
    42  	}
    43  }
    44  
    45  func TestResultString(t *testing.T) {
    46  	// Test fractional ns/op handling
    47  	r := testing.BenchmarkResult{
    48  		N: 100,
    49  		T: 240 * time.Nanosecond,
    50  	}
    51  	if r.NsPerOp() != 2 {
    52  		t.Errorf("NsPerOp: expected 2, actual %v", r.NsPerOp())
    53  	}
    54  	if want, got := "     100\t         2.400 ns/op", r.String(); want != got {
    55  		t.Errorf("String: expected %q, actual %q", want, got)
    56  	}
    57  
    58  	// Test sub-1 ns/op (issue #31005)
    59  	r.T = 40 * time.Nanosecond
    60  	if want, got := "     100\t         0.4000 ns/op", r.String(); want != got {
    61  		t.Errorf("String: expected %q, actual %q", want, got)
    62  	}
    63  
    64  	// Test 0 ns/op
    65  	r.T = 0
    66  	if want, got := "     100", r.String(); want != got {
    67  		t.Errorf("String: expected %q, actual %q", want, got)
    68  	}
    69  }
    70  
    71  func TestRunParallel(t *testing.T) {
    72  	if testing.Short() {
    73  		t.Skip("skipping in short mode")
    74  	}
    75  	testing.Benchmark(func(b *testing.B) {
    76  		procs := uint32(0)
    77  		iters := uint64(0)
    78  		b.SetParallelism(3)
    79  		b.RunParallel(func(pb *testing.PB) {
    80  			atomic.AddUint32(&procs, 1)
    81  			for pb.Next() {
    82  				atomic.AddUint64(&iters, 1)
    83  			}
    84  		})
    85  		if want := uint32(3 * runtime.GOMAXPROCS(0)); procs != want {
    86  			t.Errorf("got %v procs, want %v", procs, want)
    87  		}
    88  		if iters != uint64(b.N) {
    89  			t.Errorf("got %v iters, want %v", iters, b.N)
    90  		}
    91  	})
    92  }
    93  
    94  func TestRunParallelFail(t *testing.T) {
    95  	testing.Benchmark(func(b *testing.B) {
    96  		b.RunParallel(func(pb *testing.PB) {
    97  			// The function must be able to log/abort
    98  			// w/o crashing/deadlocking the whole benchmark.
    99  			b.Log("log")
   100  			b.Error("error")
   101  		})
   102  	})
   103  }
   104  
   105  func TestRunParallelFatal(t *testing.T) {
   106  	testing.Benchmark(func(b *testing.B) {
   107  		b.RunParallel(func(pb *testing.PB) {
   108  			for pb.Next() {
   109  				if b.N > 1 {
   110  					b.Fatal("error")
   111  				}
   112  			}
   113  		})
   114  	})
   115  }
   116  
   117  func TestRunParallelSkipNow(t *testing.T) {
   118  	testing.Benchmark(func(b *testing.B) {
   119  		b.RunParallel(func(pb *testing.PB) {
   120  			for pb.Next() {
   121  				if b.N > 1 {
   122  					b.SkipNow()
   123  				}
   124  			}
   125  		})
   126  	})
   127  }
   128  
   129  func ExampleB_RunParallel() {
   130  	// Parallel benchmark for text/template.Template.Execute on a single object.
   131  	testing.Benchmark(func(b *testing.B) {
   132  		templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))
   133  		// RunParallel will create GOMAXPROCS goroutines
   134  		// and distribute work among them.
   135  		b.RunParallel(func(pb *testing.PB) {
   136  			// Each goroutine has its own bytes.Buffer.
   137  			var buf bytes.Buffer
   138  			for pb.Next() {
   139  				// The loop body is executed b.N times total across all goroutines.
   140  				buf.Reset()
   141  				templ.Execute(&buf, "World")
   142  			}
   143  		})
   144  	})
   145  }
   146  
   147  func TestReportMetric(t *testing.T) {
   148  	res := testing.Benchmark(func(b *testing.B) {
   149  		b.ReportMetric(12345, "ns/op")
   150  		b.ReportMetric(0.2, "frobs/op")
   151  	})
   152  	// Test built-in overriding.
   153  	if res.NsPerOp() != 12345 {
   154  		t.Errorf("NsPerOp: expected %v, actual %v", 12345, res.NsPerOp())
   155  	}
   156  	// Test stringing.
   157  	res.N = 1 // Make the output stable
   158  	want := "       1\t     12345 ns/op\t         0.2000 frobs/op"
   159  	if want != res.String() {
   160  		t.Errorf("expected %q, actual %q", want, res.String())
   161  	}
   162  }
   163  
   164  func ExampleB_ReportMetric() {
   165  	// This reports a custom benchmark metric relevant to a
   166  	// specific algorithm (in this case, sorting).
   167  	testing.Benchmark(func(b *testing.B) {
   168  		var compares int64
   169  		for i := 0; i < b.N; i++ {
   170  			s := []int{5, 4, 3, 2, 1}
   171  			sort.Slice(s, func(i, j int) bool {
   172  				compares++
   173  				return s[i] < s[j]
   174  			})
   175  		}
   176  		// This metric is per-operation, so divide by b.N and
   177  		// report it as a "/op" unit.
   178  		b.ReportMetric(float64(compares)/float64(b.N), "compares/op")
   179  	})
   180  }
   181
View as plain text