package gofakeit
import (
"math"
"math/rand"
)
// Number will generate a random number between given min And max
func Number(min int, max int) int { return number(globalFaker.Rand, min, max) }
// Number will generate a random number between given min And max
func (f *Faker) Number(min int, max int) int { return number(f.Rand, min, max) }
func number(r *rand.Rand, min int, max int) int { return randIntRange(r, min, max) }
// Uint8 will generate a random uint8 value
func Uint8() uint8 { return uint8Func(globalFaker.Rand) }
// Uint8 will generate a random uint8 value
func (f *Faker) Uint8() uint8 { return uint8Func(f.Rand) }
func uint8Func(r *rand.Rand) uint8 { return uint8(randUintRange(r, minUint, math.MaxUint8)) }
// Uint16 will generate a random uint16 value
func Uint16() uint16 { return uint16Func(globalFaker.Rand) }
// Uint16 will generate a random uint16 value
func (f *Faker) Uint16() uint16 { return uint16Func(f.Rand) }
func uint16Func(r *rand.Rand) uint16 { return uint16(randUintRange(r, minUint, math.MaxUint16)) }
// Uint32 will generate a random uint32 value
func Uint32() uint32 { return uint32Func(globalFaker.Rand) }
// Uint32 will generate a random uint32 value
func (f *Faker) Uint32() uint32 { return uint32Func(f.Rand) }
func uint32Func(r *rand.Rand) uint32 { return uint32(randUintRange(r, minUint, math.MaxUint32)) }
// Uint64 will generate a random uint64 value
func Uint64() uint64 { return uint64Func(globalFaker.Rand) }
// Uint64 will generate a random uint64 value
func (f *Faker) Uint64() uint64 { return uint64Func(f.Rand) }
func uint64Func(r *rand.Rand) uint64 { return uint64(randUintRange(r, minUint, maxUint)) }
// UintRange will generate a random uint value between min and max
func UintRange(min, max uint) uint { return uintRangeFunc(globalFaker.Rand, min, max) }
// UintRange will generate a random uint value between min and max
func (f *Faker) UintRange(min, max uint) uint { return uintRangeFunc(f.Rand, min, max) }
func uintRangeFunc(r *rand.Rand, min, max uint) uint { return randUintRange(r, min, max) }
// Int8 will generate a random Int8 value
func Int8() int8 { return int8Func(globalFaker.Rand) }
// Int8 will generate a random Int8 value
func (f *Faker) Int8() int8 { return int8Func(f.Rand) }
func int8Func(r *rand.Rand) int8 { return int8(randIntRange(r, math.MinInt8, math.MaxInt8)) }
// Int16 will generate a random int16 value
func Int16() int16 { return int16Func(globalFaker.Rand) }
// Int16 will generate a random int16 value
func (f *Faker) Int16() int16 { return int16Func(f.Rand) }
func int16Func(r *rand.Rand) int16 { return int16(randIntRange(r, math.MinInt16, math.MaxInt16)) }
// Int32 will generate a random int32 value
func Int32() int32 { return int32Func(globalFaker.Rand) }
// Int32 will generate a random int32 value
func (f *Faker) Int32() int32 { return int32Func(f.Rand) }
func int32Func(r *rand.Rand) int32 { return int32(randIntRange(r, math.MinInt32, math.MaxInt32)) }
// Int64 will generate a random int64 value
func Int64() int64 { return int64Func(globalFaker.Rand) }
// Int64 will generate a random int64 value
func (f *Faker) Int64() int64 { return int64Func(f.Rand) }
func int64Func(r *rand.Rand) int64 { return int64(randIntRange(r, minInt, maxInt)) }
// IntRange will generate a random int value between min and max
func IntRange(min, max int) int { return intRangeFunc(globalFaker.Rand, min, max) }
// IntRange will generate a random int value between min and max
func (f *Faker) IntRange(min, max int) int { return intRangeFunc(f.Rand, min, max) }
func intRangeFunc(r *rand.Rand, min, max int) int { return randIntRange(r, min, max) }
// Float32 will generate a random float32 value
func Float32() float32 { return float32Func(globalFaker.Rand) }
// Float32 will generate a random float32 value
func (f *Faker) Float32() float32 { return float32Func(f.Rand) }
func float32Func(r *rand.Rand) float32 {
return float32Range(r, math.SmallestNonzeroFloat32, math.MaxFloat32)
}
// Float32Range will generate a random float32 value between min and max
func Float32Range(min, max float32) float32 {
return float32Range(globalFaker.Rand, min, max)
}
// Float32Range will generate a random float32 value between min and max
func (f *Faker) Float32Range(min, max float32) float32 {
return float32Range(f.Rand, min, max)
}
func float32Range(r *rand.Rand, min, max float32) float32 {
if min == max {
return min
}
return r.Float32()*(max-min) + min
}
// Float64 will generate a random float64 value
func Float64() float64 {
return float64Func(globalFaker.Rand)
}
// Float64 will generate a random float64 value
func (f *Faker) Float64() float64 {
return float64Func(f.Rand)
}
func float64Func(r *rand.Rand) float64 {
return float64Range(r, math.SmallestNonzeroFloat64, math.MaxFloat64)
}
// Float64Range will generate a random float64 value between min and max
func Float64Range(min, max float64) float64 {
return float64Range(globalFaker.Rand, min, max)
}
// Float64Range will generate a random float64 value between min and max
func (f *Faker) Float64Range(min, max float64) float64 {
return float64Range(f.Rand, min, max)
}
func float64Range(r *rand.Rand, min, max float64) float64 {
if min == max {
return min
}
return r.Float64()*(max-min) + min
}
// ShuffleInts will randomize a slice of ints
func ShuffleInts(a []int) { shuffleInts(globalFaker.Rand, a) }
// ShuffleInts will randomize a slice of ints
func (f *Faker) ShuffleInts(a []int) { shuffleInts(f.Rand, a) }
func shuffleInts(r *rand.Rand, a []int) {
for i := range a {
j := r.Intn(i + 1)
a[i], a[j] = a[j], a[i]
}
}
// RandomInt will take in a slice of int and return a randomly selected value
func RandomInt(i []int) int { return randomInt(globalFaker.Rand, i) }
// RandomInt will take in a slice of int and return a randomly selected value
func (f *Faker) RandomInt(i []int) int { return randomInt(f.Rand, i) }
func randomInt(r *rand.Rand, i []int) int {
size := len(i)
if size == 0 {
return 0
}
if size == 1 {
return i[0]
}
return i[r.Intn(size)]
}
// RandomUint will take in a slice of uint and return a randomly selected value
func RandomUint(u []uint) uint { return randomUint(globalFaker.Rand, u) }
// RandomUint will take in a slice of uint and return a randomly selected value
func (f *Faker) RandomUint(u []uint) uint { return randomUint(f.Rand, u) }
func randomUint(r *rand.Rand, u []uint) uint {
size := len(u)
if size == 0 {
return 0
}
if size == 1 {
return u[0]
}
return u[r.Intn(size)]
}
// HexUint8 will generate a random uint8 hex value with "0x" prefix
func HexUint8() string { return hexUint(globalFaker.Rand, 8) }
// HexUint8 will generate a random uint8 hex value with "0x" prefix
func (f *Faker) HexUint8() string { return hexUint(f.Rand, 8) }
// HexUint16 will generate a random uint16 hex value with "0x" prefix
func HexUint16() string { return hexUint(globalFaker.Rand, 16) }
// HexUint16 will generate a random uint16 hex value with "0x" prefix
func (f *Faker) HexUint16() string { return hexUint(f.Rand, 16) }
// HexUint32 will generate a random uint32 hex value with "0x" prefix
func HexUint32() string { return hexUint(globalFaker.Rand, 32) }
// HexUint32 will generate a random uint32 hex value with "0x" prefix
func (f *Faker) HexUint32() string { return hexUint(f.Rand, 32) }
// HexUint64 will generate a random uint64 hex value with "0x" prefix
func HexUint64() string { return hexUint(globalFaker.Rand, 64) }
// HexUint64 will generate a random uint64 hex value with "0x" prefix
func (f *Faker) HexUint64() string { return hexUint(f.Rand, 64) }
// HexUint128 will generate a random uint128 hex value with "0x" prefix
func HexUint128() string { return hexUint(globalFaker.Rand, 128) }
// HexUint128 will generate a random uint128 hex value with "0x" prefix
func (f *Faker) HexUint128() string { return hexUint(f.Rand, 128) }
// HexUint256 will generate a random uint256 hex value with "0x" prefix
func HexUint256() string { return hexUint(globalFaker.Rand, 256) }
// HexUint256 will generate a random uint256 hex value with "0x" prefix
func (f *Faker) HexUint256() string { return hexUint(f.Rand, 256) }
func hexUint(r *rand.Rand, bitSize int) string {
digits := []byte("0123456789abcdef")
hexLen := (bitSize >> 2) + 2
if hexLen <= 2 {
return "0x"
}
s := make([]byte, hexLen)
s[0], s[1] = '0', 'x'
for i := 2; i < hexLen; i++ {
s[i] = digits[r.Intn(16)]
}
return string(s)
}
func addNumberLookup() {
AddFuncLookup("number", Info{
Display: "Number",
Category: "number",
Description: "Mathematical concept used for counting, measuring, and expressing quantities or values",
Example: "14866",
Output: "int",
Params: []Param{
{Field: "min", Display: "Min", Type: "int", Default: "-2147483648", Description: "Minimum integer value"},
{Field: "max", Display: "Max", Type: "int", Default: "2147483647", Description: "Maximum integer value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetInt(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetInt(m, "max")
if err != nil {
return nil, err
}
return number(r, min, max), nil
},
})
AddFuncLookup("uint8", Info{
Display: "Uint8",
Category: "number",
Description: "Unsigned 8-bit integer, capable of representing values from 0 to 255",
Example: "152",
Output: "uint8",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uint8Func(r), nil
},
})
AddFuncLookup("uint16", Info{
Display: "Uint16",
Category: "number",
Description: "Unsigned 16-bit integer, capable of representing values from 0 to 65,535",
Example: "34968",
Output: "uint16",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uint16Func(r), nil
},
})
AddFuncLookup("uint32", Info{
Display: "Uint32",
Category: "number",
Description: "Unsigned 32-bit integer, capable of representing values from 0 to 4,294,967,295",
Example: "1075055705",
Output: "uint32",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uint32Func(r), nil
},
})
AddFuncLookup("uint64", Info{
Display: "Uint64",
Category: "number",
Description: "Unsigned 64-bit integer, capable of representing values from 0 to 18,446,744,073,709,551,615",
Example: "843730692693298265",
Output: "uint64",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return uint64Func(r), nil
},
})
AddFuncLookup("uintrange", Info{
Display: "UintRange",
Category: "number",
Description: "Non-negative integer value between given range",
Example: "1075055705",
Output: "uint",
Params: []Param{
{Field: "min", Display: "Min", Type: "uint", Default: "0", Description: "Minimum uint value"},
{Field: "max", Display: "Max", Type: "uint", Default: "4294967295", Description: "Maximum uint value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetUint(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetUint(m, "max")
if err != nil {
return nil, err
}
return uintRangeFunc(r, min, max), nil
},
})
AddFuncLookup("int8", Info{
Display: "Int8",
Category: "number",
Description: "Signed 8-bit integer, capable of representing values from -128 to 127",
Example: "24",
Output: "int8",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return int8Func(r), nil
},
})
AddFuncLookup("int16", Info{
Display: "Int16",
Category: "number",
Description: "Signed 16-bit integer, capable of representing values from 32,768 to 32,767",
Example: "2200",
Output: "int16",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return int16Func(r), nil
},
})
AddFuncLookup("int32", Info{
Display: "Int32",
Category: "number",
Description: "Signed 32-bit integer, capable of representing values from -2,147,483,648 to 2,147,483,647",
Example: "-1072427943",
Output: "int32",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return int32Func(r), nil
},
})
AddFuncLookup("int64", Info{
Display: "Int64",
Category: "number",
Description: "Signed 64-bit integer, capable of representing values from -9,223,372,036,854,775,808 to -9,223,372,036,854,775,807",
Example: "-8379641344161477543",
Output: "int64",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return int64Func(r), nil
},
})
AddFuncLookup("intrange", Info{
Display: "IntRange",
Category: "number",
Description: "Integer value between given range",
Example: "-8379477543",
Output: "int",
Params: []Param{
{Field: "min", Display: "Min", Type: "int", Description: "Minimum int value"},
{Field: "max", Display: "Max", Type: "int", Description: "Maximum int value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetInt(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetInt(m, "max")
if err != nil {
return nil, err
}
return intRangeFunc(r, min, max), nil
},
})
AddFuncLookup("float32", Info{
Display: "Float32",
Category: "number",
Description: "Data type representing floating-point numbers with 32 bits of precision in computing",
Example: "3.1128167e+37",
Output: "float32",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return float32Func(r), nil
},
})
AddFuncLookup("float32range", Info{
Display: "Float32 Range",
Category: "number",
Description: "Float32 value between given range",
Example: "914774.6",
Output: "float32",
Params: []Param{
{Field: "min", Display: "Min", Type: "float", Description: "Minimum float32 value"},
{Field: "max", Display: "Max", Type: "float", Description: "Maximum float32 value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetFloat32(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetFloat32(m, "max")
if err != nil {
return nil, err
}
return float32Range(r, min, max), nil
},
})
AddFuncLookup("float64", Info{
Display: "Float64",
Category: "number",
Description: "Data type representing floating-point numbers with 64 bits of precision in computing",
Example: "1.644484108270445e+307",
Output: "float64",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return float64Func(r), nil
},
})
AddFuncLookup("float64range", Info{
Display: "Float64 Range",
Category: "number",
Description: "Float64 value between given range",
Example: "914774.5585333086",
Output: "float64",
Params: []Param{
{Field: "min", Display: "Min", Type: "float", Description: "Minimum float64 value"},
{Field: "max", Display: "Max", Type: "float", Description: "Maximum float64 value"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
min, err := info.GetFloat64(m, "min")
if err != nil {
return nil, err
}
max, err := info.GetFloat64(m, "max")
if err != nil {
return nil, err
}
return float64Range(r, min, max), nil
},
})
AddFuncLookup("shuffleints", Info{
Display: "Shuffle Ints",
Category: "number",
Description: "Shuffles an array of ints",
Example: "1,2,3,4 => 3,1,4,2",
Output: "[]int",
Params: []Param{
{Field: "ints", Display: "Integers", Type: "[]int", Description: "Delimited separated integers"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
ints, err := info.GetIntArray(m, "ints")
if err != nil {
return nil, err
}
shuffleInts(r, ints)
return ints, nil
},
})
AddFuncLookup("randomint", Info{
Display: "Random Int",
Category: "number",
Description: "Randomly selected value from a slice of int",
Example: "-1,2,-3,4 => -3",
Output: "int",
Params: []Param{
{Field: "ints", Display: "Integers", Type: "[]int", Description: "Delimited separated integers"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
ints, err := info.GetIntArray(m, "ints")
if err != nil {
return nil, err
}
return randomInt(r, ints), nil
},
})
AddFuncLookup("randomuint", Info{
Display: "Random Uint",
Category: "number",
Description: "Randomly selected value from a slice of uint",
Example: "1,2,3,4 => 4",
Output: "uint",
Params: []Param{
{Field: "uints", Display: "Unsigned Integers", Type: "[]uint", Description: "Delimited separated unsigned integers"},
},
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
uints, err := info.GetUintArray(m, "uints")
if err != nil {
return nil, err
}
return randomUint(r, uints), nil
},
})
AddFuncLookup("hexuint8", Info{
Display: "HexUint8",
Category: "number",
Description: "Hexadecimal representation of an 8-bit unsigned integer",
Example: "0x87",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 8), nil
},
})
AddFuncLookup("hexuint16", Info{
Display: "HexUint16",
Category: "number",
Description: "Hexadecimal representation of an 16-bit unsigned integer",
Example: "0x8754",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 16), nil
},
})
AddFuncLookup("hexuint32", Info{
Display: "HexUint32",
Category: "number",
Description: "Hexadecimal representation of an 32-bit unsigned integer",
Example: "0x87546957",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 32), nil
},
})
AddFuncLookup("hexuint64", Info{
Display: "HexUint64",
Category: "number",
Description: "Hexadecimal representation of an 64-bit unsigned integer",
Example: "0x875469578e51b5e5",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 64), nil
},
})
AddFuncLookup("hexuint128", Info{
Display: "HexUint128",
Category: "number",
Description: "Hexadecimal representation of an 128-bit unsigned integer",
Example: "0x875469578e51b5e56c95b64681d147a1",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 128), nil
},
})
AddFuncLookup("hexuint256", Info{
Display: "HexUint256",
Category: "number",
Description: "Hexadecimal representation of an 256-bit unsigned integer",
Example: "0x875469578e51b5e56c95b64681d147a12cde48a4f417231b0c486abbc263e48d",
Output: "string",
Generate: func(r *rand.Rand, m *MapParams, info *Info) (any, error) {
return hexUint(r, 256), nil
},
})
}