func main() {
p := fmt.Print
p(rand.Intn(100), ",")
p(rand.Intn(100))
p("\n")
p(rand.Float64(), "\n")
p((rand.Float64()*5)+5, ",")
p((rand.Float64() * 5) + 5)
p("\n")
s1 := rand.NewSource(42)
r1 := rand.New(s1)
p(r1.Intn(100), ",")
p(r1.Intn(100))
p("\n")
s2 := rand.NewSource(42)
r2 := rand.New(s2)
p(r2.Intn(100), ",")
p(r2.Intn(100))
p("\n")
}
// TestBinaryDecodeMessageTable tests a large number of source messages to make
// sure they are all reconstructed accurately. This provides assurance that the
// decoder is functioning accurately.
func TestBinaryDecodeMessageTable(t *testing.T) {
c := NewBinaryCodec(10)
random := rand.New(rand.NewSource(8234982))
for i := 0; i < 100; i++ {
r := rand.New(rand.NewSource(random.Int63()))
messageLen := r.Intn(1000) + 1000
message := make([]byte, messageLen)
for j := 0; j < len(message); j++ {
message[j] = byte(r.Intn(200))
}
ids := make([]int64, 50)
for i := range ids {
ids[i] = int64(r.Intn(100000))
}
blocks := EncodeLTBlocks(message, ids, c)
d := newBinaryDecoder(c.(*binaryCodec), len(message))
d.AddBlocks(blocks[0:25])
if !d.matrix.determined() {
t.Errorf("Message should be determined after 25 blocks")
} else {
decoded := d.Decode()
if !reflect.DeepEqual(decoded, message) {
t.Errorf("Incorrect message decode. Length=%d, message=%v", len(message), message)
}
}
}
}
func main() {
fmt.Print(rand.Intn(100), ",")
fmt.Print(rand.Intn(100))
fmt.Println()
fmt.Println(rand.Float64())
fmt.Print((rand.Float64()*5)+5, ",")
fmt.Print((rand.Float64() * 5) + 5)
fmt.Println()
s1 := rand.NewSource(time.Now().UnixNano())
r1 := rand.New(s1)
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
s2 := rand.NewSource(42)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
s3 := rand.NewSource(42)
r3 := rand.New(s3)
fmt.Print(r3.Intn(100), ",")
fmt.Print(r3.Intn(100))
}
func main() {
// For example, `rand.Intn` returns a random `int` n,
// `0 <= n < 100`.
fmt.Print(rand.Intn(100), ",")
fmt.Print(rand.Intn(100))
fmt.Println()
// `rand.Float64` returns a `float64` `f`,
// `0.0 <= f < 1.0`.
fmt.Println(rand.Float64())
// To make the psuedo-random generator deterministic,
// give it a well-known seed.
s1 := rand.NewSource(42)
r1 := rand.New(s1)
// Call the resulting `rand.Source` just like the
// functions on the `rand` package.
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
// If you seed a source with the same number, it
// produces the same sequence of random numbers.
s2 := rand.NewSource(42)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
}
func main() {
fmt.Print(rand.Intn(100), ",") // rand.Intn returns random in between 0,99
fmt.Print(rand.Intn(100))
fmt.Println()
fmt.Println(rand.Float64) // random float f where 0.0 <= f < 1.0
fmt.Print((rand.Float64()*5)+5, ",")
fmt.Print((rand.Float64() * 5) + 5) // float f where 5.0 <= 5 < 10.0
fmt.Println()
// default random number generator will produce same sequence of numbers by default
// give it a seed that changes for varying sequences
// if you seed a source with the same number, it produces the same sequence of random numbers
// USE crypto/rand FOR SECRET RANDOM NUMBERS
s1 := rand.NewSource(time.Now().UnixNano())
r1 := rand.New(s1)
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
s2 := rand.NewSource(42)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
s3 := rand.NewSource(42)
r3 := rand.New(s3)
fmt.Print(r3.Intn(100), ",")
fmt.Print(r2.Intn(100))
}
func Test(t *testing.T) {
t.Parallel()
Convey("test mathrand", t, func() {
now := time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)
c, _ := testclock.UseTime(context.Background(), now)
// Note that the non-randomness below is because time is fixed at the
// top of the outer test function. Normally it would evolve with time.
Convey("unset", func() {
r := rand.New(rand.NewSource(now.UnixNano()))
i := r.Int()
So(Get(c).Int(), ShouldEqual, i)
So(Get(c).Int(), ShouldEqual, i)
})
Convey("set persistance", func() {
c = Set(c, rand.New(rand.NewSource(now.UnixNano())))
r := rand.New(rand.NewSource(now.UnixNano()))
So(Get(c).Int(), ShouldEqual, r.Int())
So(Get(c).Int(), ShouldEqual, r.Int())
})
Convey("nil set", func() {
c = Set(c, nil)
r := rand.New(rand.NewSource(now.UnixNano()))
i := r.Int()
So(Get(c).Int(), ShouldEqual, i)
So(Get(c).Int(), ShouldEqual, i)
})
})
}
func main() {
// rand.Intn return a random int n, 0 <= n < 100
fmt.Print(rand.Intn(100), ",")
fmt.Print(rand.Intn(100))
fmt.Println()
//rand.Float64 returns a float64, 0.0 <= f < 1.0
fmt.Println(rand.Float64())
// can be used to generate random floats in other ranges
// for example 5.0 <= f < 10.0
fmt.Print((rand.Float64()*5)+5, ",")
fmt.Print((rand.Float64() * 5) + 5)
fmt.Println()
s1 := rand.NewSource(time.Now().UnixNano())
r1 := rand.New(s1)
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
s2 := rand.NewSource(42)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
s3 := rand.NewSource(42)
r3 := rand.New(s3)
fmt.Print(r3.Intn(100), ",")
fmt.Print(r3.Intn(100))
}
func main() {
//例如，rand.Intn 返回一个随机的整数 n，0 <= n <= 100。
fmt.Print(rand.Intn(100), ",")
fmt.Print(rand.Intn(100))
fmt.Println()
//rand.Float64 返回一个64位浮点数 f，0.0 <= f <= 1.0。
fmt.Println(rand.Float64())
//这个技巧可以用来生成其他范围的随机浮点数，例如5.0 <= f <= 10.0
fmt.Print((rand.Float64()*5)+5, ",")
fmt.Print((rand.Float64() * 5) + 5)
fmt.Println()
//要让伪随机数生成器有确定性，可以给它一个明确的种子。
s1 := rand.NewSource(42)
r1 := rand.New(s1)
//调用上面返回的 rand.Source 的函数和调用 rand 包中函数是相同的。
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
//如果使用相同的种子生成的随机数生成器，将会产生相同的随机数序列。
s2 := rand.NewSource(42)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
}
func main() {
// 例如`rand.Intn`返回一个整型随机数n，0<=n<100
fmt.Print(rand.Intn(100), ",")
fmt.Print(rand.Intn(100))
fmt.Println()
// `rand.Float64` 返回一个`float64` `f`,
// `0.0 <= f < 1.0`
fmt.Println(rand.Float64())
// 这个方法可以用来生成其他数值范围内的随机数，
// 例如`5.0 <= f < 10.0`
fmt.Print((rand.Float64()*5)+5, ",")
fmt.Print((rand.Float64() * 5) + 5)
fmt.Println()
// 为了使随机数生成器具有确定性，可以给它一个seed
s1 := rand.NewSource(42)
r1 := rand.New(s1)
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
// 如果源使用一个和上面相同的seed，将生成一样的随机数
s2 := rand.NewSource(42)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
}
func TestBench(_ *testing.T) {
seed := NewCryptoRandSeed()
for _, name := range names {
source := rand.New(NewHashSource(hashes[name], seed))
r := testing.Benchmark(func(b *testing.B) {
for i := 0; i < b.N; i++ {
source.Int63()
}
})
fmt.Println(name, r.String(), r.MemString())
}
source := rand.New(rand.NewSource(seed))
r := testing.Benchmark(func(b *testing.B) {
for i := 0; i < b.N; i++ {
source.Int63()
}
})
fmt.Println("math/rand", r.String(), r.MemString())
}
// TestbinaryDecoderBlockTable tests many combinations of fountain block ID
// combinations to ensure that the codec has the expected reconstruction
// properties.
func TestBinaryDecoderBlockTable(t *testing.T) {
c := NewBinaryCodec(13)
message := []byte("abcdefghijklmnopqrstuvwxyz")
random := rand.New(rand.NewSource(8234923))
moreBlocksNeeded := 0
for i := 0; i < 100; i++ {
r := rand.New(rand.NewSource(random.Int63()))
ids := make([]int64, 45)
for i := range ids {
ids[i] = int64(r.Intn(100000))
}
blocks := EncodeLTBlocks(message, ids, c)
d := newBinaryDecoder(c.(*binaryCodec), len(message))
d.AddBlocks(blocks[0:30])
if !d.matrix.determined() {
moreBlocksNeeded++
d.AddBlocks(blocks[31:46])
}
decoded := d.Decode()
if !reflect.DeepEqual(decoded, message) {
t.Errorf("Decoded message doesn't match original. Got %v, want %v", decoded, message)
}
}
if moreBlocksNeeded > 2 {
t.Errorf("Needed too many high-block-count decoding sequences: %d", moreBlocksNeeded)
}
}
func main() {
//For example, rand.Intn returns a random int n, 0 <= n < 100.
fmt.Print(rand.Intn(100), ",")
fmt.Print(rand.Intn(100))
fmt.Println()
//rand.Float64 returns a float64 f, 0.0 <= f < 1.0.
fmt.Println(rand.Float64())
//This can be used to generate random floats in other ranges, for example 5.0 <= f' < 10.0.
fmt.Print((rand.Float64()*5)+5, ",")
fmt.Print((rand.Float64() * 5) + 5)
fmt.Println()
//The default number generator is deterministic, so it’ll produce the same sequence of numbers each time by default. To produce varying sequences, give it a seed that changes. Note that this is not safe to use for random numbers you intend to be secret, use crypto/rand for those.
s1 := rand.NewSource(time.Now().UnixNano())
r1 := rand.New(s1)
//Call the resulting rand.Rand just like the functions on the rand package.
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
//If you seed a source with the same number, it produces the same sequence of random numbers.
s2 := rand.NewSource(42)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
s3 := rand.NewSource(42)
r3 := rand.New(s3)
fmt.Print(r3.Intn(100), ",")
fmt.Print(r3.Intn(100))
}
func outOfOrder(l *list.List) {
iTotal := 25
if iTotal > l.Len() {
iTotal = l.Len()
}
ll := make([]*list.List, iTotal)
for i := 0; i < iTotal; i++ {
ll[i] = list.New()
}
r := rand.New(rand.NewSource(time.Now().UnixNano()))
for e := l.Front(); e != nil; e = e.Next() {
fpath, ok := e.Value.(string)
if !ok {
panic("The path is invalid string")
}
if rand.Int()%2 == 0 {
ll[r.Intn(iTotal)].PushFront(fpath)
} else {
ll[r.Intn(iTotal)].PushBack(fpath)
}
}
r0 := rand.New(rand.NewSource(time.Now().UnixNano()))
l.Init()
for i := 0; i < iTotal; i++ {
if r0.Intn(2) == 0 {
l.PushBackList(ll[i])
} else {
l.PushFrontList(ll[i])
}
ll[i].Init()
}
}
// Marshals a Message and hands it to the Stack. If toSelf is true,
// the message is also dispatched to the local instance's RecvMsgSync.
func (instance *pbftCore) innerBroadcast(msg *Message) error {
msgRaw, err := proto.Marshal(msg)
if err != nil {
return fmt.Errorf("Cannot marshal message %s", err)
}
doByzantine := false
if instance.byzantine {
rand1 := rand.New(rand.NewSource(time.Now().UnixNano()))
doIt := rand1.Intn(3) // go byzantine about 1/3 of the time
if doIt == 1 {
doByzantine = true
}
}
// testing byzantine fault.
if doByzantine {
rand2 := rand.New(rand.NewSource(time.Now().UnixNano()))
ignoreidx := rand2.Intn(instance.N)
for i := 0; i < instance.N; i++ {
if i != ignoreidx && uint64(i) != instance.id { //Pick a random replica and do not send message
instance.consumer.unicast(msgRaw, uint64(i))
} else {
logger.Debugf("PBFT byzantine: not broadcasting to replica %v", i)
}
}
} else {
instance.consumer.broadcast(msgRaw)
}
return nil
}
func TestDecodeMessageTable(t *testing.T) {
c := NewOnlineCodec(10, 0.2, 7, 0).(*onlineCodec)
random := rand.New(rand.NewSource(8234982))
for i := 0; i < 100; i++ {
c.randomSeed = random.Int63()
r := rand.New(rand.NewSource(random.Int63()))
messageLen := r.Intn(1000) + 1000
message := make([]byte, messageLen)
for j := 0; j < len(message); j++ {
message[j] = byte(r.Intn(200))
}
ids := make([]int64, 50)
for i := range ids {
ids[i] = int64(r.Intn(100000))
}
blocks := encodeOnlineBlocks(message, ids, *c)
d := newOnlineDecoder(c, len(message))
d.AddBlocks(blocks[0:25])
if !d.matrix.determined() {
t.Errorf("Message should be determined after 25 blocks")
} else {
decoded := d.Decode()
if !reflect.DeepEqual(decoded, message) {
t.Errorf("Incorrect message decode. Length=%d", len(message))
}
}
}
}
func main() {
fmt.Print(rand.Intn(100), ",")
fmt.Print(rand.Intn(100))
fmt.Println()
fmt.Println(rand.Float64())
fmt.Print((rand.Float64()*5)+5, ",")
fmt.Print((rand.Float64() * 5) + 5)
fmt.Println()
s1 := rand.NewSource(42)
r1 := rand.New(s1)
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
s2 := rand.NewSource(42)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
}
// Fuzz test for N iterations
func testTypeFuzzN(t *testing.T, base interface{}, ff interface{}, n int) {
require.Implements(t, (*json.Marshaler)(nil), ff)
require.Implements(t, (*json.Unmarshaler)(nil), ff)
require.Implements(t, (*marshalerFaster)(nil), ff)
require.Implements(t, (*unmarshalFaster)(nil), ff)
if _, ok := base.(unmarshalFaster); ok {
require.FailNow(t, "base should not have a UnmarshalJSONFFLexer")
}
if _, ok := base.(marshalerFaster); ok {
require.FailNow(t, "base should not have a MarshalJSONBuf")
}
f := fuzz.New()
f.NumElements(0, 1+n/40)
f.NilChance(0.2)
f.Funcs(fuzzTime, fuzzTimeSlice)
for i := 0; i < n; i++ {
f.RandSource(rand.New(rand.NewSource(int64(i * 5275))))
f.Fuzz(base)
f.RandSource(rand.New(rand.NewSource(int64(i * 5275))))
f.Fuzz(ff)
testSameMarshal(t, base, ff)
testCycle(t, base, ff)
}
}
func New(db database.Database, dbConfig config.DbConfig) strategy.Strategy {
return &rankStrategy{
isNewRand: rand.New(rand.NewSource(time.Now().Unix())),
rankRand: rand.New(rand.NewSource(time.Now().Add(time.Hour).Unix())),
db: db,
dbConfig: dbConfig,
}
}
func TestTargetRequest(t *testing.T) {
t.Parallel()
body := []byte(`{"id": "{foo}", "value": "bar"}`)
tgt := Target{
Method: "GET",
URL: "http://{foo}:9999/",
Body: body,
Header: http.Header{
"X-Some-Header": []string{"1"},
"X-Some-Other-Header": []string{"2"},
"X-Some-New-Header": []string{"3"},
"Host": []string{"lolcathost"},
},
URLInterpolators: []URLInterpolator{
&RandomNumericInterpolation{
Key: "{foo}",
Limit: int(^uint(0) >> 1),
Rand: rand.New(rand.NewSource(1435875839)),
},
},
BodyInterpolators: []BodyInterpolator{
&RandomNumericInterpolation{
Key: "{foo}",
Limit: int(^uint(0) >> 1),
Rand: rand.New(rand.NewSource(1435875839)),
},
},
}
req, _ := tgt.Request()
reqBody, err := ioutil.ReadAll(req.Body)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal([]byte(`{"id": "2290778204292519845", "value": "bar"}`), reqBody) {
t.Fatalf("Target body wasn't copied correctly")
}
if req.URL.String() != "http://2290778204292519845:9999/" {
t.Fatalf("Target URL wasn't resolved correctly")
}
tgt.Header.Set("X-Stuff", "0")
if req.Header.Get("X-Stuff") == "0" {
t.Error("Each Target must have its own Header")
}
want, got := tgt.Header.Get("Host"), req.Header.Get("Host")
if want != got {
t.Fatalf("Target Header wasn't copied correctly. Want: %s, Got: %s", want, got)
}
if req.Host != want {
t.Fatalf("Target Host wasnt copied correctly. Want: %s, Got: %s", want, req.Host)
}
}
func TestLRUCache_ConcurrentSetGet(t *testing.T) {
runtime.GOMAXPROCS(runtime.NumCPU())
seed := time.Now().UnixNano()
t.Logf("seed=%d", seed)
const (
N = 2000000
M = 4000
C = 3
)
var set, get uint32
wg := &sync.WaitGroup{}
c := NewLRUCache(M / 4)
for ni := uint64(0); ni < C; ni++ {
r0 := rand.New(rand.NewSource(seed + int64(ni)))
r1 := rand.New(rand.NewSource(seed + int64(ni) + 1))
ns := c.GetNamespace(ni)
wg.Add(2)
go func(ns Namespace, r *rand.Rand) {
for i := 0; i < N; i++ {
x := uint64(r.Int63n(M))
o := ns.Get(x, func() (int, interface{}) {
atomic.AddUint32(&set, 1)
return 1, x
})
if v := o.Value().(uint64); v != x {
t.Errorf("#%d invalid value, got=%d", x, v)
}
o.Release()
}
wg.Done()
}(ns, r0)
go func(ns Namespace, r *rand.Rand) {
for i := 0; i < N; i++ {
x := uint64(r.Int63n(M))
o := ns.Get(x, nil)
if o != nil {
atomic.AddUint32(&get, 1)
if v := o.Value().(uint64); v != x {
t.Errorf("#%d invalid value, got=%d", x, v)
}
o.Release()
}
}
wg.Done()
}(ns, r1)
}
wg.Wait()
t.Logf("set=%d get=%d", set, get)
}
func TestRandomIntFromDist(t *testing.T) {
dist := []float64{0.1, 0.2, 0.3, 0.4}
r := rand.New(rand.NewSource(33))
res1 := make([]int, 100, 100)
for range res1 {
res1 = append(res1, RandIntFromDist(dist, r))
}
// Checking that experiments are repeatable.
r = rand.New(rand.NewSource(33))
res2 := make([]int, 100, 100)
for range res2 {
res2 = append(res2, RandIntFromDist(dist, r))
}
gjoa.CompareSliceInt(t, res1, res1, "sequence mismatch")
r = rand.New(rand.NewSource(33))
res := make(map[int]float64)
var n float64 = 100000
for i := 0.0; i < n; i++ {
res[RandIntFromDist(dist, r)]++
}
actual := make([]float64, len(dist), len(dist))
for k, v := range res {
p := v / n
t.Log(k, v, p)
actual[k] = p
}
gjoa.CompareSliceFloat(t, dist, actual, "probs don't match, error in RandIntFromDist", 0.02)
// same with log probs
logDist := make([]float64, len(dist), len(dist))
for k, v := range dist {
logDist[k] = math.Log(v)
}
r = rand.New(rand.NewSource(33))
res = make(map[int]float64)
for i := 0.0; i < n; i++ {
res[RandIntFromLogDist(logDist, r)]++
}
for k, v := range res {
p := v / n
t.Log(k, v, p)
actual[k] = p
}
gjoa.CompareSliceFloat(t, dist, actual, "probs don't match, error in RandIntFromLogDist", 0.02)
}
// Returns some random start position for a sun, before starting
// to move it over the galaxy
func getRandomStartPosition(scope int) *vec2d.Vector {
xSeed := time.Now().UTC().UnixNano()
ySeed := time.Now().UTC().UnixNano()
xGenerator := rand.New(rand.NewSource(xSeed))
yGenerator := rand.New(rand.NewSource(ySeed))
return vec2d.New(
float64(xGenerator.Intn(scope)-scope/2),
float64(yGenerator.Intn(scope)-scope/2),
)
}
func main() {
channel := Channel{tail: 0, head: 0, count: 0}
channel.init(5)
channel.startWorkers()
go ClientThread{channel: &channel, random: rand.New(rand.NewSource(time.Now().Unix()))}.Start("Alice")
go ClientThread{channel: &channel, random: rand.New(rand.NewSource(time.Now().Unix()))}.Start("Bobby")
go ClientThread{channel: &channel, random: rand.New(rand.NewSource(time.Now().Unix()))}.Start("Chris")
select {}
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
requestQueue := RequestQueue{queue: list.New()}
clientThread := ClientThread{random: rand.New(rand.NewSource(time.Now().UnixNano())), requestQueue: requestQueue}
serverThread := ServerThread{random: rand.New(rand.NewSource(time.Now().UnixNano())), requestQueue: requestQueue}
go clientThread.run()
go serverThread.run()
select {}
}
func NewDice(seed int) dice {
d := dice{}
if seed != -1 {
d.r = rand.New(rand.NewSource(int64(seed)))
} else {
d.r = rand.New(rand.NewSource(time.Now().UnixNano()))
}
return d
}
func benchMergeInPlace(b *testing.B, size int) {
s := rand.NewSource(int64(size))
x := rand.New(s).Perm(2 * size / 3)
y := rand.New(s).Perm(size / 3)
sort.Ints(x)
sort.Ints(y)
b.ResetTimer()
for i := 0; i < b.N; i++ {
MergeInPlace(x, y)
}
}
// lostrate: 往返一周丢包率的百分比，默认 10%
// rttmin：rtt最小值，默认 60
// rttmax：rtt最大值，默认 125
//func (p *LatencySimulator)Init(int lostrate = 10, int rttmin = 60, int rttmax = 125, int nmax = 1000):
func (p *LatencySimulator) Init(lostrate, rttmin, rttmax, nmax int) {
p.r12 = rand.New(rand.NewSource(9))
p.r21 = rand.New(rand.NewSource(99))
p.p12 = DelayTunnel{list.New()}
p.p21 = DelayTunnel{list.New()}
p.current = iclock()
p.lostrate = lostrate / 2 // 上面数据是往返丢包率，单程除以2
p.rttmin = rttmin / 2
p.rttmax = rttmax / 2
p.nmax = nmax
}
func Rand(v ...*big.Int) (*big.Int, error) {
switch len(v) {
case 1:
return new(big.Int).Rand(rand.New(rand.NewSource(time.Now().UnixNano())), v[0]), nil
case 2:
delta := new(big.Int).Sub(v[1], v[0])
r := new(big.Int).Rand(rand.New(rand.NewSource(time.Now().UnixNano())), delta)
return r.Add(r, v[0]), nil
}
return nil, ArgCountErr
}
func (c *MaxPDVolumeCountChecker) filterVolumes(volumes []v1.Volume, namespace string, filteredVolumes map[string]bool) error {
for i := range volumes {
vol := &volumes[i]
if id, ok := c.filter.FilterVolume(vol); ok {
filteredVolumes[id] = true
} else if vol.PersistentVolumeClaim != nil {
pvcName := vol.PersistentVolumeClaim.ClaimName
if pvcName == "" {
return fmt.Errorf("PersistentVolumeClaim had no name")
}
pvc, err := c.pvcInfo.GetPersistentVolumeClaimInfo(namespace, pvcName)
if err != nil {
// if the PVC is not found, log the error and count the PV towards the PV limit
// generate a random volume ID since its required for de-dup
utilruntime.HandleError(fmt.Errorf("Unable to look up PVC info for %s/%s, assuming PVC matches predicate when counting limits: %v", namespace, pvcName, err))
source := rand.NewSource(time.Now().UnixNano())
generatedID := "missingPVC" + strconv.Itoa(rand.New(source).Intn(1000000))
filteredVolumes[generatedID] = true
return nil
}
if pvc == nil {
return fmt.Errorf("PersistentVolumeClaim not found: %q", pvcName)
}
pvName := pvc.Spec.VolumeName
if pvName == "" {
return fmt.Errorf("PersistentVolumeClaim is not bound: %q", pvcName)
}
pv, err := c.pvInfo.GetPersistentVolumeInfo(pvName)
if err != nil {
// if the PV is not found, log the error
// and count the PV towards the PV limit
// generate a random volume ID since its required for de-dup
utilruntime.HandleError(fmt.Errorf("Unable to look up PV info for %s/%s/%s, assuming PV matches predicate when counting limits: %v", namespace, pvcName, pvName, err))
source := rand.NewSource(time.Now().UnixNano())
generatedID := "missingPV" + strconv.Itoa(rand.New(source).Intn(1000000))
filteredVolumes[generatedID] = true
return nil
}
if pv == nil {
return fmt.Errorf("PersistentVolume not found: %q", pvName)
}
if id, ok := c.filter.FilterPersistentVolume(pv); ok {
filteredVolumes[id] = true
}
}
}
return nil
}
func (p *dbBench) randomize() {
m := len(p.keys)
times := m * 2
r1, r2 := rand.New(rand.NewSource(0xdeadbeef)), rand.New(rand.NewSource(0xbeefface))
for n := 0; n < times; n++ {
i, j := r1.Int()%m, r2.Int()%m
if i == j {
continue
}
p.keys[i], p.keys[j] = p.keys[j], p.keys[i]
p.values[i], p.values[j] = p.values[j], p.values[i]
}
}