Source file src/math/rand/rand_test.go

Documentation: math/rand

     1  // Copyright 2009 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 rand_test
     6  
     7  import (
     8  	"bytes"
     9  	"errors"
    10  	"fmt"
    11  	"internal/testenv"
    12  	"io"
    13  	"math"
    14  	. "math/rand"
    15  	"os"
    16  	"runtime"
    17  	"testing"
    18  	"testing/iotest"
    19  )
    20  
    21  const (
    22  	numTestSamples = 10000
    23  )
    24  
    25  var rn, kn, wn, fn = GetNormalDistributionParameters()
    26  var re, ke, we, fe = GetExponentialDistributionParameters()
    27  
    28  type statsResults struct {
    29  	mean        float64
    30  	stddev      float64
    31  	closeEnough float64
    32  	maxError    float64
    33  }
    34  
    35  func max(a, b float64) float64 {
    36  	if a > b {
    37  		return a
    38  	}
    39  	return b
    40  }
    41  
    42  func nearEqual(a, b, closeEnough, maxError float64) bool {
    43  	absDiff := math.Abs(a - b)
    44  	if absDiff < closeEnough { // Necessary when one value is zero and one value is close to zero.
    45  		return true
    46  	}
    47  	return absDiff/max(math.Abs(a), math.Abs(b)) < maxError
    48  }
    49  
    50  var testSeeds = []int64{1, 1754801282, 1698661970, 1550503961}
    51  
    52  // checkSimilarDistribution returns success if the mean and stddev of the
    53  // two statsResults are similar.
    54  func (this *statsResults) checkSimilarDistribution(expected *statsResults) error {
    55  	if !nearEqual(this.mean, expected.mean, expected.closeEnough, expected.maxError) {
    56  		s := fmt.Sprintf("mean %v != %v (allowed error %v, %v)", this.mean, expected.mean, expected.closeEnough, expected.maxError)
    57  		fmt.Println(s)
    58  		return errors.New(s)
    59  	}
    60  	if !nearEqual(this.stddev, expected.stddev, expected.closeEnough, expected.maxError) {
    61  		s := fmt.Sprintf("stddev %v != %v (allowed error %v, %v)", this.stddev, expected.stddev, expected.closeEnough, expected.maxError)
    62  		fmt.Println(s)
    63  		return errors.New(s)
    64  	}
    65  	return nil
    66  }
    67  
    68  func getStatsResults(samples []float64) *statsResults {
    69  	res := new(statsResults)
    70  	var sum, squaresum float64
    71  	for _, s := range samples {
    72  		sum += s
    73  		squaresum += s * s
    74  	}
    75  	res.mean = sum / float64(len(samples))
    76  	res.stddev = math.Sqrt(squaresum/float64(len(samples)) - res.mean*res.mean)
    77  	return res
    78  }
    79  
    80  func checkSampleDistribution(t *testing.T, samples []float64, expected *statsResults) {
    81  	t.Helper()
    82  	actual := getStatsResults(samples)
    83  	err := actual.checkSimilarDistribution(expected)
    84  	if err != nil {
    85  		t.Errorf(err.Error())
    86  	}
    87  }
    88  
    89  func checkSampleSliceDistributions(t *testing.T, samples []float64, nslices int, expected *statsResults) {
    90  	t.Helper()
    91  	chunk := len(samples) / nslices
    92  	for i := 0; i < nslices; i++ {
    93  		low := i * chunk
    94  		var high int
    95  		if i == nslices-1 {
    96  			high = len(samples) - 1
    97  		} else {
    98  			high = (i + 1) * chunk
    99  		}
   100  		checkSampleDistribution(t, samples[low:high], expected)
   101  	}
   102  }
   103  
   104  //
   105  // Normal distribution tests
   106  //
   107  
   108  func generateNormalSamples(nsamples int, mean, stddev float64, seed int64) []float64 {
   109  	r := New(NewSource(seed))
   110  	samples := make([]float64, nsamples)
   111  	for i := range samples {
   112  		samples[i] = r.NormFloat64()*stddev + mean
   113  	}
   114  	return samples
   115  }
   116  
   117  func testNormalDistribution(t *testing.T, nsamples int, mean, stddev float64, seed int64) {
   118  	//fmt.Printf("testing nsamples=%v mean=%v stddev=%v seed=%v\n", nsamples, mean, stddev, seed);
   119  
   120  	samples := generateNormalSamples(nsamples, mean, stddev, seed)
   121  	errorScale := max(1.0, stddev) // Error scales with stddev
   122  	expected := &statsResults{mean, stddev, 0.10 * errorScale, 0.08 * errorScale}
   123  
   124  	// Make sure that the entire set matches the expected distribution.
   125  	checkSampleDistribution(t, samples, expected)
   126  
   127  	// Make sure that each half of the set matches the expected distribution.
   128  	checkSampleSliceDistributions(t, samples, 2, expected)
   129  
   130  	// Make sure that each 7th of the set matches the expected distribution.
   131  	checkSampleSliceDistributions(t, samples, 7, expected)
   132  }
   133  
   134  // Actual tests
   135  
   136  func TestStandardNormalValues(t *testing.T) {
   137  	for _, seed := range testSeeds {
   138  		testNormalDistribution(t, numTestSamples, 0, 1, seed)
   139  	}
   140  }
   141  
   142  func TestNonStandardNormalValues(t *testing.T) {
   143  	sdmax := 1000.0
   144  	mmax := 1000.0
   145  	if testing.Short() {
   146  		sdmax = 5
   147  		mmax = 5
   148  	}
   149  	for sd := 0.5; sd < sdmax; sd *= 2 {
   150  		for m := 0.5; m < mmax; m *= 2 {
   151  			for _, seed := range testSeeds {
   152  				testNormalDistribution(t, numTestSamples, m, sd, seed)
   153  				if testing.Short() {
   154  					break
   155  				}
   156  			}
   157  		}
   158  	}
   159  }
   160  
   161  //
   162  // Exponential distribution tests
   163  //
   164  
   165  func generateExponentialSamples(nsamples int, rate float64, seed int64) []float64 {
   166  	r := New(NewSource(seed))
   167  	samples := make([]float64, nsamples)
   168  	for i := range samples {
   169  		samples[i] = r.ExpFloat64() / rate
   170  	}
   171  	return samples
   172  }
   173  
   174  func testExponentialDistribution(t *testing.T, nsamples int, rate float64, seed int64) {
   175  	//fmt.Printf("testing nsamples=%v rate=%v seed=%v\n", nsamples, rate, seed);
   176  
   177  	mean := 1 / rate
   178  	stddev := mean
   179  
   180  	samples := generateExponentialSamples(nsamples, rate, seed)
   181  	errorScale := max(1.0, 1/rate) // Error scales with the inverse of the rate
   182  	expected := &statsResults{mean, stddev, 0.10 * errorScale, 0.20 * errorScale}
   183  
   184  	// Make sure that the entire set matches the expected distribution.
   185  	checkSampleDistribution(t, samples, expected)
   186  
   187  	// Make sure that each half of the set matches the expected distribution.
   188  	checkSampleSliceDistributions(t, samples, 2, expected)
   189  
   190  	// Make sure that each 7th of the set matches the expected distribution.
   191  	checkSampleSliceDistributions(t, samples, 7, expected)
   192  }
   193  
   194  // Actual tests
   195  
   196  func TestStandardExponentialValues(t *testing.T) {
   197  	for _, seed := range testSeeds {
   198  		testExponentialDistribution(t, numTestSamples, 1, seed)
   199  	}
   200  }
   201  
   202  func TestNonStandardExponentialValues(t *testing.T) {
   203  	for rate := 0.05; rate < 10; rate *= 2 {
   204  		for _, seed := range testSeeds {
   205  			testExponentialDistribution(t, numTestSamples, rate, seed)
   206  			if testing.Short() {
   207  				break
   208  			}
   209  		}
   210  	}
   211  }
   212  
   213  //
   214  // Table generation tests
   215  //
   216  
   217  func initNorm() (testKn []uint32, testWn, testFn []float32) {
   218  	const m1 = 1 << 31
   219  	var (
   220  		dn float64 = rn
   221  		tn         = dn
   222  		vn float64 = 9.91256303526217e-3
   223  	)
   224  
   225  	testKn = make([]uint32, 128)
   226  	testWn = make([]float32, 128)
   227  	testFn = make([]float32, 128)
   228  
   229  	q := vn / math.Exp(-0.5*dn*dn)
   230  	testKn[0] = uint32((dn / q) * m1)
   231  	testKn[1] = 0
   232  	testWn[0] = float32(q / m1)
   233  	testWn[127] = float32(dn / m1)
   234  	testFn[0] = 1.0
   235  	testFn[127] = float32(math.Exp(-0.5 * dn * dn))
   236  	for i := 126; i >= 1; i-- {
   237  		dn = math.Sqrt(-2.0 * math.Log(vn/dn+math.Exp(-0.5*dn*dn)))
   238  		testKn[i+1] = uint32((dn / tn) * m1)
   239  		tn = dn
   240  		testFn[i] = float32(math.Exp(-0.5 * dn * dn))
   241  		testWn[i] = float32(dn / m1)
   242  	}
   243  	return
   244  }
   245  
   246  func initExp() (testKe []uint32, testWe, testFe []float32) {
   247  	const m2 = 1 << 32
   248  	var (
   249  		de float64 = re
   250  		te         = de
   251  		ve float64 = 3.9496598225815571993e-3
   252  	)
   253  
   254  	testKe = make([]uint32, 256)
   255  	testWe = make([]float32, 256)
   256  	testFe = make([]float32, 256)
   257  
   258  	q := ve / math.Exp(-de)
   259  	testKe[0] = uint32((de / q) * m2)
   260  	testKe[1] = 0
   261  	testWe[0] = float32(q / m2)
   262  	testWe[255] = float32(de / m2)
   263  	testFe[0] = 1.0
   264  	testFe[255] = float32(math.Exp(-de))
   265  	for i := 254; i >= 1; i-- {
   266  		de = -math.Log(ve/de + math.Exp(-de))
   267  		testKe[i+1] = uint32((de / te) * m2)
   268  		te = de
   269  		testFe[i] = float32(math.Exp(-de))
   270  		testWe[i] = float32(de / m2)
   271  	}
   272  	return
   273  }
   274  
   275  // compareUint32Slices returns the first index where the two slices
   276  // disagree, or <0 if the lengths are the same and all elements
   277  // are identical.
   278  func compareUint32Slices(s1, s2 []uint32) int {
   279  	if len(s1) != len(s2) {
   280  		if len(s1) > len(s2) {
   281  			return len(s2) + 1
   282  		}
   283  		return len(s1) + 1
   284  	}
   285  	for i := range s1 {
   286  		if s1[i] != s2[i] {
   287  			return i
   288  		}
   289  	}
   290  	return -1
   291  }
   292  
   293  // compareFloat32Slices returns the first index where the two slices
   294  // disagree, or <0 if the lengths are the same and all elements
   295  // are identical.
   296  func compareFloat32Slices(s1, s2 []float32) int {
   297  	if len(s1) != len(s2) {
   298  		if len(s1) > len(s2) {
   299  			return len(s2) + 1
   300  		}
   301  		return len(s1) + 1
   302  	}
   303  	for i := range s1 {
   304  		if !nearEqual(float64(s1[i]), float64(s2[i]), 0, 1e-7) {
   305  			return i
   306  		}
   307  	}
   308  	return -1
   309  }
   310  
   311  func TestNormTables(t *testing.T) {
   312  	testKn, testWn, testFn := initNorm()
   313  	if i := compareUint32Slices(kn[0:], testKn); i >= 0 {
   314  		t.Errorf("kn disagrees at index %v; %v != %v", i, kn[i], testKn[i])
   315  	}
   316  	if i := compareFloat32Slices(wn[0:], testWn); i >= 0 {
   317  		t.Errorf("wn disagrees at index %v; %v != %v", i, wn[i], testWn[i])
   318  	}
   319  	if i := compareFloat32Slices(fn[0:], testFn); i >= 0 {
   320  		t.Errorf("fn disagrees at index %v; %v != %v", i, fn[i], testFn[i])
   321  	}
   322  }
   323  
   324  func TestExpTables(t *testing.T) {
   325  	testKe, testWe, testFe := initExp()
   326  	if i := compareUint32Slices(ke[0:], testKe); i >= 0 {
   327  		t.Errorf("ke disagrees at index %v; %v != %v", i, ke[i], testKe[i])
   328  	}
   329  	if i := compareFloat32Slices(we[0:], testWe); i >= 0 {
   330  		t.Errorf("we disagrees at index %v; %v != %v", i, we[i], testWe[i])
   331  	}
   332  	if i := compareFloat32Slices(fe[0:], testFe); i >= 0 {
   333  		t.Errorf("fe disagrees at index %v; %v != %v", i, fe[i], testFe[i])
   334  	}
   335  }
   336  
   337  func hasSlowFloatingPoint() bool {
   338  	switch runtime.GOARCH {
   339  	case "arm":
   340  		return os.Getenv("GOARM") == "5"
   341  	case "mips", "mipsle", "mips64", "mips64le":
   342  		// Be conservative and assume that all mips boards
   343  		// have emulated floating point.
   344  		// TODO: detect what it actually has.
   345  		return true
   346  	}
   347  	return false
   348  }
   349  
   350  func TestFloat32(t *testing.T) {
   351  	// For issue 6721, the problem came after 7533753 calls, so check 10e6.
   352  	num := int(10e6)
   353  	// But do the full amount only on builders (not locally).
   354  	// But ARM5 floating point emulation is slow (Issue 10749), so
   355  	// do less for that builder:
   356  	if testing.Short() && (testenv.Builder() == "" || hasSlowFloatingPoint()) {
   357  		num /= 100 // 1.72 seconds instead of 172 seconds
   358  	}
   359  
   360  	r := New(NewSource(1))
   361  	for ct := 0; ct < num; ct++ {
   362  		f := r.Float32()
   363  		if f >= 1 {
   364  			t.Fatal("Float32() should be in range [0,1). ct:", ct, "f:", f)
   365  		}
   366  	}
   367  }
   368  
   369  func testReadUniformity(t *testing.T, n int, seed int64) {
   370  	r := New(NewSource(seed))
   371  	buf := make([]byte, n)
   372  	nRead, err := r.Read(buf)
   373  	if err != nil {
   374  		t.Errorf("Read err %v", err)
   375  	}
   376  	if nRead != n {
   377  		t.Errorf("Read returned unexpected n; %d != %d", nRead, n)
   378  	}
   379  
   380  	// Expect a uniform distribution of byte values, which lie in [0, 255].
   381  	var (
   382  		mean       = 255.0 / 2
   383  		stddev     = 256.0 / math.Sqrt(12.0)
   384  		errorScale = stddev / math.Sqrt(float64(n))
   385  	)
   386  
   387  	expected := &statsResults{mean, stddev, 0.10 * errorScale, 0.08 * errorScale}
   388  
   389  	// Cast bytes as floats to use the common distribution-validity checks.
   390  	samples := make([]float64, n)
   391  	for i, val := range buf {
   392  		samples[i] = float64(val)
   393  	}
   394  	// Make sure that the entire set matches the expected distribution.
   395  	checkSampleDistribution(t, samples, expected)
   396  }
   397  
   398  func TestReadUniformity(t *testing.T) {
   399  	testBufferSizes := []int{
   400  		2, 4, 7, 64, 1024, 1 << 16, 1 << 20,
   401  	}
   402  	for _, seed := range testSeeds {
   403  		for _, n := range testBufferSizes {
   404  			testReadUniformity(t, n, seed)
   405  		}
   406  	}
   407  }
   408  
   409  func TestReadEmpty(t *testing.T) {
   410  	r := New(NewSource(1))
   411  	buf := make([]byte, 0)
   412  	n, err := r.Read(buf)
   413  	if err != nil {
   414  		t.Errorf("Read err into empty buffer; %v", err)
   415  	}
   416  	if n != 0 {
   417  		t.Errorf("Read into empty buffer returned unexpected n of %d", n)
   418  	}
   419  }
   420  
   421  func TestReadByOneByte(t *testing.T) {
   422  	r := New(NewSource(1))
   423  	b1 := make([]byte, 100)
   424  	_, err := io.ReadFull(iotest.OneByteReader(r), b1)
   425  	if err != nil {
   426  		t.Errorf("read by one byte: %v", err)
   427  	}
   428  	r = New(NewSource(1))
   429  	b2 := make([]byte, 100)
   430  	_, err = r.Read(b2)
   431  	if err != nil {
   432  		t.Errorf("read: %v", err)
   433  	}
   434  	if !bytes.Equal(b1, b2) {
   435  		t.Errorf("read by one byte vs single read:\n%x\n%x", b1, b2)
   436  	}
   437  }
   438  
   439  func TestReadSeedReset(t *testing.T) {
   440  	r := New(NewSource(42))
   441  	b1 := make([]byte, 128)
   442  	_, err := r.Read(b1)
   443  	if err != nil {
   444  		t.Errorf("read: %v", err)
   445  	}
   446  	r.Seed(42)
   447  	b2 := make([]byte, 128)
   448  	_, err = r.Read(b2)
   449  	if err != nil {
   450  		t.Errorf("read: %v", err)
   451  	}
   452  	if !bytes.Equal(b1, b2) {
   453  		t.Errorf("mismatch after re-seed:\n%x\n%x", b1, b2)
   454  	}
   455  }
   456  
   457  func TestShuffleSmall(t *testing.T) {
   458  	// Check that Shuffle allows n=0 and n=1, but that swap is never called for them.
   459  	r := New(NewSource(1))
   460  	for n := 0; n <= 1; n++ {
   461  		r.Shuffle(n, func(i, j int) { t.Fatalf("swap called, n=%d i=%d j=%d", n, i, j) })
   462  	}
   463  }
   464  
   465  // encodePerm converts from a permuted slice of length n, such as Perm generates, to an int in [0, n!).
   466  // See https://en.wikipedia.org/wiki/Lehmer_code.
   467  // encodePerm modifies the input slice.
   468  func encodePerm(s []int) int {
   469  	// Convert to Lehmer code.
   470  	for i, x := range s {
   471  		r := s[i+1:]
   472  		for j, y := range r {
   473  			if y > x {
   474  				r[j]--
   475  			}
   476  		}
   477  	}
   478  	// Convert to int in [0, n!).
   479  	m := 0
   480  	fact := 1
   481  	for i := len(s) - 1; i >= 0; i-- {
   482  		m += s[i] * fact
   483  		fact *= len(s) - i
   484  	}
   485  	return m
   486  }
   487  
   488  // TestUniformFactorial tests several ways of generating a uniform value in [0, n!).
   489  func TestUniformFactorial(t *testing.T) {
   490  	r := New(NewSource(testSeeds[0]))
   491  	top := 6
   492  	if testing.Short() {
   493  		top = 3
   494  	}
   495  	for n := 3; n <= top; n++ {
   496  		t.Run(fmt.Sprintf("n=%d", n), func(t *testing.T) {
   497  			// Calculate n!.
   498  			nfact := 1
   499  			for i := 2; i <= n; i++ {
   500  				nfact *= i
   501  			}
   502  
   503  			// Test a few different ways to generate a uniform distribution.
   504  			p := make([]int, n) // re-usable slice for Shuffle generator
   505  			tests := [...]struct {
   506  				name string
   507  				fn   func() int
   508  			}{
   509  				{name: "Int31n", fn: func() int { return int(r.Int31n(int32(nfact))) }},
   510  				{name: "int31n", fn: func() int { return int(Int31nForTest(r, int32(nfact))) }},
   511  				{name: "Perm", fn: func() int { return encodePerm(r.Perm(n)) }},
   512  				{name: "Shuffle", fn: func() int {
   513  					// Generate permutation using Shuffle.
   514  					for i := range p {
   515  						p[i] = i
   516  					}
   517  					r.Shuffle(n, func(i, j int) { p[i], p[j] = p[j], p[i] })
   518  					return encodePerm(p)
   519  				}},
   520  			}
   521  
   522  			for _, test := range tests {
   523  				t.Run(test.name, func(t *testing.T) {
   524  					// Gather chi-squared values and check that they follow
   525  					// the expected normal distribution given n!-1 degrees of freedom.
   526  					// See https://en.wikipedia.org/wiki/Pearson%27s_chi-squared_test and
   527  					// https://www.johndcook.com/Beautiful_Testing_ch10.pdf.
   528  					nsamples := 10 * nfact
   529  					if nsamples < 200 {
   530  						nsamples = 200
   531  					}
   532  					samples := make([]float64, nsamples)
   533  					for i := range samples {
   534  						// Generate some uniformly distributed values and count their occurrences.
   535  						const iters = 1000
   536  						counts := make([]int, nfact)
   537  						for i := 0; i < iters; i++ {
   538  							counts[test.fn()]++
   539  						}
   540  						// Calculate chi-squared and add to samples.
   541  						want := iters / float64(nfact)
   542  						var χ2 float64
   543  						for _, have := range counts {
   544  							err := float64(have) - want
   545  							χ2 += err * err
   546  						}
   547  						χ2 /= want
   548  						samples[i] = χ2
   549  					}
   550  
   551  					// Check that our samples approximate the appropriate normal distribution.
   552  					dof := float64(nfact - 1)
   553  					expected := &statsResults{mean: dof, stddev: math.Sqrt(2 * dof)}
   554  					errorScale := max(1.0, expected.stddev)
   555  					expected.closeEnough = 0.10 * errorScale
   556  					expected.maxError = 0.08 // TODO: What is the right value here? See issue 21211.
   557  					checkSampleDistribution(t, samples, expected)
   558  				})
   559  			}
   560  		})
   561  	}
   562  }
   563  
   564  // Benchmarks
   565  
   566  func BenchmarkInt63Threadsafe(b *testing.B) {
   567  	for n := b.N; n > 0; n-- {
   568  		Int63()
   569  	}
   570  }
   571  
   572  func BenchmarkInt63ThreadsafeParallel(b *testing.B) {
   573  	b.RunParallel(func(pb *testing.PB) {
   574  		for pb.Next() {
   575  			Int63()
   576  		}
   577  	})
   578  }
   579  
   580  func BenchmarkInt63Unthreadsafe(b *testing.B) {
   581  	r := New(NewSource(1))
   582  	for n := b.N; n > 0; n-- {
   583  		r.Int63()
   584  	}
   585  }
   586  
   587  func BenchmarkIntn1000(b *testing.B) {
   588  	r := New(NewSource(1))
   589  	for n := b.N; n > 0; n-- {
   590  		r.Intn(1000)
   591  	}
   592  }
   593  
   594  func BenchmarkInt63n1000(b *testing.B) {
   595  	r := New(NewSource(1))
   596  	for n := b.N; n > 0; n-- {
   597  		r.Int63n(1000)
   598  	}
   599  }
   600  
   601  func BenchmarkInt31n1000(b *testing.B) {
   602  	r := New(NewSource(1))
   603  	for n := b.N; n > 0; n-- {
   604  		r.Int31n(1000)
   605  	}
   606  }
   607  
   608  func BenchmarkFloat32(b *testing.B) {
   609  	r := New(NewSource(1))
   610  	for n := b.N; n > 0; n-- {
   611  		r.Float32()
   612  	}
   613  }
   614  
   615  func BenchmarkFloat64(b *testing.B) {
   616  	r := New(NewSource(1))
   617  	for n := b.N; n > 0; n-- {
   618  		r.Float64()
   619  	}
   620  }
   621  
   622  func BenchmarkPerm3(b *testing.B) {
   623  	r := New(NewSource(1))
   624  	for n := b.N; n > 0; n-- {
   625  		r.Perm(3)
   626  	}
   627  }
   628  
   629  func BenchmarkPerm30(b *testing.B) {
   630  	r := New(NewSource(1))
   631  	for n := b.N; n > 0; n-- {
   632  		r.Perm(30)
   633  	}
   634  }
   635  
   636  func BenchmarkPerm30ViaShuffle(b *testing.B) {
   637  	r := New(NewSource(1))
   638  	for n := b.N; n > 0; n-- {
   639  		p := make([]int, 30)
   640  		for i := range p {
   641  			p[i] = i
   642  		}
   643  		r.Shuffle(30, func(i, j int) { p[i], p[j] = p[j], p[i] })
   644  	}
   645  }
   646  
   647  // BenchmarkShuffleOverhead uses a minimal swap function
   648  // to measure just the shuffling overhead.
   649  func BenchmarkShuffleOverhead(b *testing.B) {
   650  	r := New(NewSource(1))
   651  	for n := b.N; n > 0; n-- {
   652  		r.Shuffle(52, func(i, j int) {
   653  			if i < 0 || i >= 52 || j < 0 || j >= 52 {
   654  				b.Fatalf("bad swap(%d, %d)", i, j)
   655  			}
   656  		})
   657  	}
   658  }
   659  
   660  func BenchmarkRead3(b *testing.B) {
   661  	r := New(NewSource(1))
   662  	buf := make([]byte, 3)
   663  	b.ResetTimer()
   664  	for n := b.N; n > 0; n-- {
   665  		r.Read(buf)
   666  	}
   667  }
   668  
   669  func BenchmarkRead64(b *testing.B) {
   670  	r := New(NewSource(1))
   671  	buf := make([]byte, 64)
   672  	b.ResetTimer()
   673  	for n := b.N; n > 0; n-- {
   674  		r.Read(buf)
   675  	}
   676  }
   677  
   678  func BenchmarkRead1000(b *testing.B) {
   679  	r := New(NewSource(1))
   680  	buf := make([]byte, 1000)
   681  	b.ResetTimer()
   682  	for n := b.N; n > 0; n-- {
   683  		r.Read(buf)
   684  	}
   685  }
   686  

View as plain text