random

package
v0.151.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 11, 2024 License: Apache-2.0 Imports: 25 Imported by: 4

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Charset 

func Charset() string

func CharsetASCII 

func CharsetASCII() string

func CharsetAlpha 

func CharsetAlpha() string

func CharsetDigit 

func CharsetDigit() string

func KV 

func KV[K comparable, V any](mkK func() K, mkV func() V) func() (K, V)

func Map 

func Map[K comparable, V any](length int, mk func() (K, V)) map[K]V

func Pick added in v0.146.0 

func Pick[T any](rnd *Random, vs ...T) T
Example (PseudoRandomValuePicking) 
package main

import (
	"go.llib.dev/testcase/random"
	"math/rand"
)

func main() {
	// Pick pseudo randomly from the given values using the seed.
	// This will make picking deterministically random when the same seed is used.
	const seed = 42
	rnd := random.New(rand.NewSource(seed))
	var _ = random.Pick(rnd, "one", "two", "three")
}

Output:
Example (RandomValuePicking) 
package main

import (
	"go.llib.dev/testcase/random"
)

func main() {
	// Pick randomly from the values of 1,2,3
	var _ = random.Pick(nil, 1, 2, 3)
}

Output:

func Slice 

func Slice[T any](length int, mk func() T) []T

func Unique added in v0.145.0 

func Unique[T any](blk func() T, excludeList ...T) T

Unique function is a utility that helps with generating distinct values from those in a given exclusion list. If you need multiple unique values of the same type, this helper function can be useful for ensuring they're all different. 

rnd := random.New(random.CryptoSeed{})
v1 := random.Unique(rnd.Int)
v2 := random.Unique(rnd.Int, v1)
v3 := random.Unique(rnd.Int, v1, v2)
Example 
package main

import (
	"go.llib.dev/testcase/assert"
	"go.llib.dev/testcase/random"
	"testing"
)

func main() {
	// useful when you need random values which are not equal
	rnd := random.New(random.CryptoSeed{})
	v1 := rnd.Int()
	v2 := random.Unique(rnd.Int, v1)
	v3 := random.Unique(rnd.Int, v1, v2)

	var tb testing.TB
	assert.NotEqual(tb, v1, v3)
	assert.NotEqual(tb, v2, v3)
}

Output:

Types

type Contact 

type Contact struct {
	FirstName string
	LastName  string
	Email     string
}

type CryptoSeed 

type CryptoSeed struct{}

func (CryptoSeed) Int63 

func (c CryptoSeed) Int63() int64

Int63 returns a non-negative pseudo-random 63-bit integer as an int64.

func (CryptoSeed) Seed 

func (c CryptoSeed) Seed(seed int64)

Seed should use the provided seed value to initialize the generator to a deterministic state, but in CryptoSeed, the value is ignored.

func (CryptoSeed) Uint64 

func (c CryptoSeed) Uint64() uint64

type Factory 

type Factory struct {
	// contains filtered or unexported fields
}

func (*Factory) Make 

func (f *Factory) Make(rnd *Random, T any) (_T any)

func (*Factory) RegisterType 

func (f *Factory) RegisterType(T any, ff typeFunc)

type Random 

type Random struct {
	Source  rand.Source
	Factory Factory
	// contains filtered or unexported fields
}

A Random is a source of random numbers. It is safe to be used in from multiple goroutines.

Example (CryptoSeed) 
package main

import (
	"go.llib.dev/testcase/random"
)

func main() {
	random.New(random.CryptoSeed{})
}

Output:
Example (MathRand) 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	seed := time.Now().UnixNano()
	source := rand.NewSource(seed)
	random.New(source)
}

Output:

func New 

func New(s rand.Source) *Random
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	_ = random.New(rand.NewSource(time.Now().Unix()))
}

Output:

func (*Random) Bool 

func (r *Random) Bool() bool
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.Bool() // returns a random bool
}

Output:

func (*Random) Contact 

func (r *Random) Contact(opts ...internal.ContactOption) Contact

func (*Random) Domain added in v0.148.0 

func (r *Random) Domain() string

Domain will return a valid domain name.

func (*Random) Email 

func (r *Random) Email() string

Email

DEPRECATED: please use Contact.Email from Random.Contact instead

func (*Random) Error 

func (r *Random) Error() error
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	err := rnd.Error()
	_ = err
}

Output:

func (*Random) Float32 

func (r *Random) Float32() float32

Float32 returns, as a float32, a pseudo-random number in [0.0,1.0).

Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.Float32()
}

Output:

func (*Random) Float64 

func (r *Random) Float64() float64

Float64 returns, as a float64, a pseudo-random number in [0.0,1.0).

Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.Float64()
}

Output:

func (*Random) Int 

func (r *Random) Int() int

Int returns a non-negative pseudo-random int.

Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.Int()
}

Output:

func (*Random) IntB 

func (r *Random) IntB(min, max int) int

IntB returns, as an int, a non-negative pseudo-random number based on the received int range's [min,max].

func (*Random) IntBetween 

func (r *Random) IntBetween(min, max int) int

IntBetween returns, as an int, a non-negative pseudo-random number based on the received int range's [min,max].

Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.IntBetween(24, 42)
}

Output:

func (*Random) IntN 

func (r *Random) IntN(n int) int

IntN returns, as an int, a non-negative pseudo-random number in [0,n). It panics if n <= 0.

Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.IntN(42)
}

Output:

func (*Random) Make 

func (r *Random) Make(T any) any
Example 
package main

import (
	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(random.CryptoSeed{})

	type ExampleStruct struct {
		Foo string
		Bar int
		Baz *int
	}

	_ = rnd.Make(&ExampleStruct{}).(*ExampleStruct) // returns a populated struct
}

Output:

func (*Random) Name 

func (r *Random) Name() contactGenerator

Name

DEPRECATED: please use Random.Contact instead

func (*Random) Read 

func (r *Random) Read(p []byte) (n int, err error)
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	p := make([]byte, 42)
	n, err := rnd.Read(p)

	_, _ = n, err
}

Output:

func (*Random) Repeat 

func (r *Random) Repeat(min, max int, do func()) int

Repeat will repeatedly call the "do" function. The number of repeats will be random between the min and the max range. The repeated time will be returned as a result.

Example 
package main

import (
	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(random.CryptoSeed{})

	n := rnd.Repeat(1, 3, func() {
		// will be called repeatedly between 1 and 3 times.
	})

	_ = n // is the number of times, the function block was repeated.
}

Output:

func (*Random) SliceElement 

func (r *Random) SliceElement(slice interface{}) interface{}

SliceElement will return a random slice element. You need type assert the returned value to get back the original type.

Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	// returns a random element from the given slice
	_ = rnd.SliceElement([]string{`foo`, `bar`, `baz`}).(string)
}

Output:

func (*Random) String 

func (r *Random) String() string
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.String()
}

Output:

func (*Random) StringN 

func (r *Random) StringN(length int) string
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.StringN(42)
}

Output:

func (*Random) StringNC 

func (r *Random) StringNC(length int, charset string) string
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))
	rnd.StringNC(42, random.Charset())
	rnd.StringNC(42, random.CharsetASCII())
	rnd.StringNC(42, random.CharsetAlpha())
	rnd.StringNC(42, "ABC")
}

Output:

func (*Random) StringNWithCharset 

func (r *Random) StringNWithCharset(length int, charset string) string
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))
	rnd.StringNWithCharset(42, random.Charset())
	rnd.StringNWithCharset(42, random.CharsetASCII())
	rnd.StringNWithCharset(42, random.CharsetAlpha())
	rnd.StringNWithCharset(42, "ABC")
}

Output:

func (*Random) Time 

func (r *Random) Time() time.Time
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.Time()
}

Output:

func (*Random) TimeB 

func (r *Random) TimeB(from, to time.Time) time.Time

TimeB returns, as an time.Time, a non-negative pseudo-random time in [from,to].

func (*Random) TimeBetween 

func (r *Random) TimeBetween(from, to time.Time) time.Time

TimeBetween returns, as an time.Time, a non-negative pseudo-random time in [from,to].

Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))

	_ = rnd.TimeBetween(time.Now(), time.Now().Add(time.Hour))
}

Output:

func (*Random) TimeN 

func (r *Random) TimeN(from time.Time, years, months, days int) time.Time
Example 
package main

import (
	"math/rand"
	"time"

	"go.llib.dev/testcase/random"
)

func main() {
	rnd := random.New(rand.NewSource(time.Now().Unix()))
	var (
		years  = 0
		months = 4
		days   = 2
	)
	_ = rnd.TimeN(time.Now(), years, months, days)
}

Output:

func (*Random) UUID 

func (r *Random) UUID() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.