You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
120 lines
2.8 KiB
120 lines
2.8 KiB
package common
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
mrand "math/rand"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestRandStr(t *testing.T) {
|
|
l := 243
|
|
s := RandStr(l)
|
|
assert.Equal(t, l, len(s))
|
|
}
|
|
|
|
func TestRandBytes(t *testing.T) {
|
|
l := 243
|
|
b := RandBytes(l)
|
|
assert.Equal(t, l, len(b))
|
|
}
|
|
|
|
func TestRandIntn(t *testing.T) {
|
|
n := 243
|
|
for i := 0; i < 100; i++ {
|
|
x := RandIntn(n)
|
|
assert.True(t, x < n)
|
|
}
|
|
}
|
|
|
|
// It is essential that these tests run and never repeat their outputs
|
|
// lest we've been pwned and the behavior of our randomness is controlled.
|
|
// See Issues:
|
|
// * https://github.com/tendermint/tmlibs/issues/99
|
|
// * https://github.com/tendermint/tendermint/issues/973
|
|
func TestUniqueRng(t *testing.T) {
|
|
buf := new(bytes.Buffer)
|
|
outputs := make(map[string][]int)
|
|
for i := 0; i < 100; i++ {
|
|
testThemAll(buf)
|
|
output := buf.String()
|
|
buf.Reset()
|
|
runs, seen := outputs[output]
|
|
if seen {
|
|
t.Errorf("Run #%d's output was already seen in previous runs: %v", i, runs)
|
|
}
|
|
outputs[output] = append(outputs[output], i)
|
|
}
|
|
}
|
|
|
|
func testThemAll(out io.Writer) {
|
|
// Reset the internal PRNG
|
|
reset()
|
|
|
|
// Set math/rand's Seed so that any direct invocations
|
|
// of math/rand will reveal themselves.
|
|
mrand.Seed(1)
|
|
perm := RandPerm(10)
|
|
blob, _ := json.Marshal(perm)
|
|
fmt.Fprintf(out, "perm: %s\n", blob)
|
|
|
|
fmt.Fprintf(out, "randInt: %d\n", RandInt())
|
|
fmt.Fprintf(out, "randUint: %d\n", RandUint())
|
|
fmt.Fprintf(out, "randIntn: %d\n", RandIntn(97))
|
|
fmt.Fprintf(out, "randInt31: %d\n", RandInt31())
|
|
fmt.Fprintf(out, "randInt32: %d\n", RandInt32())
|
|
fmt.Fprintf(out, "randInt63: %d\n", RandInt63())
|
|
fmt.Fprintf(out, "randInt64: %d\n", RandInt64())
|
|
fmt.Fprintf(out, "randUint32: %d\n", RandUint32())
|
|
fmt.Fprintf(out, "randUint64: %d\n", RandUint64())
|
|
fmt.Fprintf(out, "randUint16Exp: %d\n", RandUint16Exp())
|
|
fmt.Fprintf(out, "randUint32Exp: %d\n", RandUint32Exp())
|
|
fmt.Fprintf(out, "randUint64Exp: %d\n", RandUint64Exp())
|
|
}
|
|
|
|
func TestRngConcurrencySafety(t *testing.T) {
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 100; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
|
|
_ = RandUint64()
|
|
<-time.After(time.Millisecond * time.Duration(RandIntn(100)))
|
|
_ = RandPerm(3)
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func BenchmarkRandBytes10B(b *testing.B) {
|
|
benchmarkRandBytes(b, 10)
|
|
}
|
|
func BenchmarkRandBytes100B(b *testing.B) {
|
|
benchmarkRandBytes(b, 100)
|
|
}
|
|
func BenchmarkRandBytes1KiB(b *testing.B) {
|
|
benchmarkRandBytes(b, 1024)
|
|
}
|
|
func BenchmarkRandBytes10KiB(b *testing.B) {
|
|
benchmarkRandBytes(b, 10*1024)
|
|
}
|
|
func BenchmarkRandBytes100KiB(b *testing.B) {
|
|
benchmarkRandBytes(b, 100*1024)
|
|
}
|
|
func BenchmarkRandBytes1MiB(b *testing.B) {
|
|
benchmarkRandBytes(b, 1024*1024)
|
|
}
|
|
|
|
func benchmarkRandBytes(b *testing.B, n int) {
|
|
for i := 0; i < b.N; i++ {
|
|
_ = RandBytes(n)
|
|
}
|
|
b.ReportAllocs()
|
|
}
|