...
Run Format

Source file src/testing/benchmark_test.go

Documentation: testing

     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  	"sync/atomic"
    11  	"testing"
    12  	"text/template"
    13  )
    14  
    15  var roundDownTests = []struct {
    16  	v, expected int
    17  }{
    18  	{1, 1},
    19  	{9, 1},
    20  	{10, 10},
    21  	{11, 10},
    22  	{100, 100},
    23  	{101, 100},
    24  	{999, 100},
    25  	{1000, 1000},
    26  	{1001, 1000},
    27  }
    28  
    29  func TestRoundDown10(t *testing.T) {
    30  	for _, tt := range roundDownTests {
    31  		actual := testing.RoundDown10(tt.v)
    32  		if tt.expected != actual {
    33  			t.Errorf("roundDown10(%d): expected %d, actual %d", tt.v, tt.expected, actual)
    34  		}
    35  	}
    36  }
    37  
    38  var roundUpTests = []struct {
    39  	v, expected int
    40  }{
    41  	{0, 1},
    42  	{1, 1},
    43  	{2, 2},
    44  	{3, 3},
    45  	{5, 5},
    46  	{9, 10},
    47  	{999, 1000},
    48  	{1000, 1000},
    49  	{1400, 2000},
    50  	{1700, 2000},
    51  	{2700, 3000},
    52  	{4999, 5000},
    53  	{5000, 5000},
    54  	{5001, 10000},
    55  }
    56  
    57  func TestRoundUp(t *testing.T) {
    58  	for _, tt := range roundUpTests {
    59  		actual := testing.RoundUp(tt.v)
    60  		if tt.expected != actual {
    61  			t.Errorf("roundUp(%d): expected %d, actual %d", tt.v, tt.expected, actual)
    62  		}
    63  	}
    64  }
    65  
    66  func TestRunParallel(t *testing.T) {
    67  	testing.Benchmark(func(b *testing.B) {
    68  		procs := uint32(0)
    69  		iters := uint64(0)
    70  		b.SetParallelism(3)
    71  		b.RunParallel(func(pb *testing.PB) {
    72  			atomic.AddUint32(&procs, 1)
    73  			for pb.Next() {
    74  				atomic.AddUint64(&iters, 1)
    75  			}
    76  		})
    77  		if want := uint32(3 * runtime.GOMAXPROCS(0)); procs != want {
    78  			t.Errorf("got %v procs, want %v", procs, want)
    79  		}
    80  		if iters != uint64(b.N) {
    81  			t.Errorf("got %v iters, want %v", iters, b.N)
    82  		}
    83  	})
    84  }
    85  
    86  func TestRunParallelFail(t *testing.T) {
    87  	testing.Benchmark(func(b *testing.B) {
    88  		b.RunParallel(func(pb *testing.PB) {
    89  			// The function must be able to log/abort
    90  			// w/o crashing/deadlocking the whole benchmark.
    91  			b.Log("log")
    92  			b.Error("error")
    93  		})
    94  	})
    95  }
    96  
    97  func ExampleB_RunParallel() {
    98  	// Parallel benchmark for text/template.Template.Execute on a single object.
    99  	testing.Benchmark(func(b *testing.B) {
   100  		templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))
   101  		// RunParallel will create GOMAXPROCS goroutines
   102  		// and distribute work among them.
   103  		b.RunParallel(func(pb *testing.PB) {
   104  			// Each goroutine has its own bytes.Buffer.
   105  			var buf bytes.Buffer
   106  			for pb.Next() {
   107  				// The loop body is executed b.N times total across all goroutines.
   108  				buf.Reset()
   109  				templ.Execute(&buf, "World")
   110  			}
   111  		})
   112  	})
   113  }
   114  

View as plain text