Home | History | Annotate | Download | only in 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