386 lines
10 KiB
Go
386 lines
10 KiB
Go
|
// Copyright 2009 The Go Authors. All rights reserved.
|
||
|
|
// Use of this source code is governed by a BSD-style
|
||
|
|
// license that can be found in the LICENSE file.
|
||
|
|
|
||
|
|
// Package quick implements utility functions to help with black box testing.
|
||
|
|
//
|
||
|
|
// The testing/quick package is frozen and is not accepting new features.
|
||
|
|
package quick
|
||
|
|
|
||
|
|
import (
|
||
|
|
"flag"
|
||
|
|
"fmt"
|
||
|
|
"math"
|
||
|
|
"math/rand"
|
||
|
|
"reflect"
|
||
|
|
"strings"
|
||
|
|
"time"
|
||
|
|
)
|
||
|
|
|
||
|
|
var defaultMaxCount *int = flag.Int("quickchecks", 100, "The default number of iterations for each check")
|
||
|
|
|
||
|
|
// A Generator can generate random values of its own type.
|
||
|
|
type Generator interface {
|
||
|
|
// Generate returns a random instance of the type on which it is a
|
||
|
|
// method using the size as a size hint.
|
||
|
|
Generate(rand *rand.Rand, size int) reflect.Value
|
||
|
|
}
|
||
|
|
|
||
|
|
// randFloat32 generates a random float taking the full range of a float32.
|
||
|
|
func randFloat32(rand *rand.Rand) float32 {
|
||
|
|
f := rand.Float64() * math.MaxFloat32
|
||
|
|
if rand.Int()&1 == 1 {
|
||
|
|
f = -f
|
||
|
|
}
|
||
|
|
return float32(f)
|
||
|
|
}
|
||
|
|
|
||
|
|
// randFloat64 generates a random float taking the full range of a float64.
|
||
|
|
func randFloat64(rand *rand.Rand) float64 {
|
||
|
|
f := rand.Float64() * math.MaxFloat64
|
||
|
|
if rand.Int()&1 == 1 {
|
||
|
|
f = -f
|
||
|
|
}
|
||
|
|
return f
|
||
|
|
}
|
||
|
|
|
||
|
|
// randInt64 returns a random int64.
|
||
|
|
func randInt64(rand *rand.Rand) int64 {
|
||
|
|
return int64(rand.Uint64())
|
||
|
|
}
|
||
|
|
|
||
|
|
// complexSize is the maximum length of arbitrary values that contain other
|
||
|
|
// values.
|
||
|
|
const complexSize = 50
|
||
|
|
|
||
|
|
// Value returns an arbitrary value of the given type.
|
||
|
|
// If the type implements the Generator interface, that will be used.
|
||
|
|
// Note: To create arbitrary values for structs, all the fields must be exported.
|
||
|
|
func Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool) {
|
||
|
|
return sizedValue(t, rand, complexSize)
|
||
|
|
}
|
||
|
|
|
||
|
|
// sizedValue returns an arbitrary value of the given type. The size
|
||
|
|
// hint is used for shrinking as a function of indirection level so
|
||
|
|
// that recursive data structures will terminate.
|
||
|
|
func sizedValue(t reflect.Type, rand *rand.Rand, size int) (value reflect.Value, ok bool) {
|
||
|
|
if m, ok := reflect.Zero(t).Interface().(Generator); ok {
|
||
|
|
return m.Generate(rand, size), true
|
||
|
|
}
|
||
|
|
|
||
|
|
v := reflect.New(t).Elem()
|
||
|
|
switch concrete := t; concrete.Kind() {
|
||
|
|
case reflect.Bool:
|
||
|
|
v.SetBool(rand.Int()&1 == 0)
|
||
|
|
case reflect.Float32:
|
||
|
|
v.SetFloat(float64(randFloat32(rand)))
|
||
|
|
case reflect.Float64:
|
||
|
|
v.SetFloat(randFloat64(rand))
|
||
|
|
case reflect.Complex64:
|
||
|
|
v.SetComplex(complex(float64(randFloat32(rand)), float64(randFloat32(rand))))
|
||
|
|
case reflect.Complex128:
|
||
|
|
v.SetComplex(complex(randFloat64(rand), randFloat64(rand)))
|
||
|
|
case reflect.Int16:
|
||
|
|
v.SetInt(randInt64(rand))
|
||
|
|
case reflect.Int32:
|
||
|
|
v.SetInt(randInt64(rand))
|
||
|
|
case reflect.Int64:
|
||
|
|
v.SetInt(randInt64(rand))
|
||
|
|
case reflect.Int8:
|
||
|
|
v.SetInt(randInt64(rand))
|
||
|
|
case reflect.Int:
|
||
|
|
v.SetInt(randInt64(rand))
|
||
|
|
case reflect.Uint16:
|
||
|
|
v.SetUint(uint64(randInt64(rand)))
|
||
|
|
case reflect.Uint32:
|
||
|
|
v.SetUint(uint64(randInt64(rand)))
|
||
|
|
case reflect.Uint64:
|
||
|
|
v.SetUint(uint64(randInt64(rand)))
|
||
|
|
case reflect.Uint8:
|
||
|
|
v.SetUint(uint64(randInt64(rand)))
|
||
|
|
case reflect.Uint:
|
||
|
|
v.SetUint(uint64(randInt64(rand)))
|
||
|
|
case reflect.Uintptr:
|
||
|
|
v.SetUint(uint64(randInt64(rand)))
|
||
|
|
case reflect.Map:
|
||
|
|
numElems := rand.Intn(size)
|
||
|
|
v.Set(reflect.MakeMap(concrete))
|
||
|
|
for i := 0; i < numElems; i++ {
|
||
|
|
key, ok1 := sizedValue(concrete.Key(), rand, size)
|
||
|
|
value, ok2 := sizedValue(concrete.Elem(), rand, size)
|
||
|
|
if !ok1 || !ok2 {
|
||
|
|
return reflect.Value{}, false
|
||
|
|
}
|
||
|
|
v.SetMapIndex(key, value)
|
||
|
|
}
|
||
|
|
case reflect.Pointer:
|
||
|
|
if rand.Intn(size) == 0 {
|
||
|
|
v.Set(reflect.Zero(concrete)) // Generate nil pointer.
|
||
|
|
} else {
|
||
|
|
elem, ok := sizedValue(concrete.Elem(), rand, size)
|
||
|
|
if !ok {
|
||
|
|
return reflect.Value{}, false
|
||
|
|
}
|
||
|
|
v.Set(reflect.New(concrete.Elem()))
|
||
|
|
v.Elem().Set(elem)
|
||
|
|
}
|
||
|
|
case reflect.Slice:
|
||
|
|
numElems := rand.Intn(size)
|
||
|
|
sizeLeft := size - numElems
|
||
|
|
v.Set(reflect.MakeSlice(concrete, numElems, numElems))
|
||
|
|
for i := 0; i < numElems; i++ {
|
||
|
|
elem, ok := sizedValue(concrete.Elem(), rand, sizeLeft)
|
||
|
|
if !ok {
|
||
|
|
return reflect.Value{}, false
|
||
|
|
}
|
||
|
|
v.Index(i).Set(elem)
|
||
|
|
}
|
||
|
|
case reflect.Array:
|
||
|
|
for i := 0; i < v.Len(); i++ {
|
||
|
|
elem, ok := sizedValue(concrete.Elem(), rand, size)
|
||
|
|
if !ok {
|
||
|
|
return reflect.Value{}, false
|
||
|
|
}
|
||
|
|
v.Index(i).Set(elem)
|
||
|
|
}
|
||
|
|
case reflect.String:
|
||
|
|
numChars := rand.Intn(complexSize)
|
||
|
|
codePoints := make([]rune, numChars)
|
||
|
|
for i := 0; i < numChars; i++ {
|
||
|
|
codePoints[i] = rune(rand.Intn(0x10ffff))
|
||
|
|
}
|
||
|
|
v.SetString(string(codePoints))
|
||
|
|
case reflect.Struct:
|
||
|
|
n := v.NumField()
|
||
|
|
// Divide sizeLeft evenly among the struct fields.
|
||
|
|
sizeLeft := size
|
||
|
|
if n > sizeLeft {
|
||
|
|
sizeLeft = 1
|
||
|
|
} else if n > 0 {
|
||
|
|
sizeLeft /= n
|
||
|
|
}
|
||
|
|
for i := 0; i < n; i++ {
|
||
|
|
elem, ok := sizedValue(concrete.Field(i).Type, rand, sizeLeft)
|
||
|
|
if !ok {
|
||
|
|
return reflect.Value{}, false
|
||
|
|
}
|
||
|
|
v.Field(i).Set(elem)
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
return reflect.Value{}, false
|
||
|
|
}
|
||
|
|
|
||
|
|
return v, true
|
||
|
|
}
|
||
|
|
|
||
|
|
// A Config structure contains options for running a test.
|
||
|
|
type Config struct {
|
||
|
|
// MaxCount sets the maximum number of iterations.
|
||
|
|
// If zero, MaxCountScale is used.
|
||
|
|
MaxCount int
|
||
|
|
// MaxCountScale is a non-negative scale factor applied to the
|
||
|
|
// default maximum.
|
||
|
|
// A count of zero implies the default, which is usually 100
|
||
|
|
// but can be set by the -quickchecks flag.
|
||
|
|
MaxCountScale float64
|
||
|
|
// Rand specifies a source of random numbers.
|
||
|
|
// If nil, a default pseudo-random source will be used.
|
||
|
|
Rand *rand.Rand
|
||
|
|
// Values specifies a function to generate a slice of
|
||
|
|
// arbitrary reflect.Values that are congruent with the
|
||
|
|
// arguments to the function being tested.
|
||
|
|
// If nil, the top-level Value function is used to generate them.
|
||
|
|
Values func([]reflect.Value, *rand.Rand)
|
||
|
|
}
|
||
|
|
|
||
|
|
var defaultConfig Config
|
||
|
|
|
||
|
|
// getRand returns the *rand.Rand to use for a given Config.
|
||
|
|
func (c *Config) getRand() *rand.Rand {
|
||
|
|
if c.Rand == nil {
|
||
|
|
return rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
|
|
}
|
||
|
|
return c.Rand
|
||
|
|
}
|
||
|
|
|
||
|
|
// getMaxCount returns the maximum number of iterations to run for a given
|
||
|
|
// Config.
|
||
|
|
func (c *Config) getMaxCount() (maxCount int) {
|
||
|
|
maxCount = c.MaxCount
|
||
|
|
if maxCount == 0 {
|
||
|
|
if c.MaxCountScale != 0 {
|
||
|
|
maxCount = int(c.MaxCountScale * float64(*defaultMaxCount))
|
||
|
|
} else {
|
||
|
|
maxCount = *defaultMaxCount
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// A SetupError is the result of an error in the way that check is being
|
||
|
|
// used, independent of the functions being tested.
|
||
|
|
type SetupError string
|
||
|
|
|
||
|
|
func (s SetupError) Error() string { return string(s) }
|
||
|
|
|
||
|
|
// A CheckError is the result of Check finding an error.
|
||
|
|
type CheckError struct {
|
||
|
|
Count int
|
||
|
|
In []any
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *CheckError) Error() string {
|
||
|
|
return fmt.Sprintf("#%d: failed on input %s", s.Count, toString(s.In))
|
||
|
|
}
|
||
|
|
|
||
|
|
// A CheckEqualError is the result CheckEqual finding an error.
|
||
|
|
type CheckEqualError struct {
|
||
|
|
CheckError
|
||
|
|
Out1 []any
|
||
|
|
Out2 []any
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *CheckEqualError) Error() string {
|
||
|
|
return fmt.Sprintf("#%d: failed on input %s. Output 1: %s. Output 2: %s", s.Count, toString(s.In), toString(s.Out1), toString(s.Out2))
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check looks for an input to f, any function that returns bool,
|
||
|
|
// such that f returns false. It calls f repeatedly, with arbitrary
|
||
|
|
// values for each argument. If f returns false on a given input,
|
||
|
|
// Check returns that input as a *CheckError.
|
||
|
|
// For example:
|
||
|
|
//
|
||
|
|
// func TestOddMultipleOfThree(t *testing.T) {
|
||
|
|
// f := func(x int) bool {
|
||
|
|
// y := OddMultipleOfThree(x)
|
||
|
|
// return y%2 == 1 && y%3 == 0
|
||
|
|
// }
|
||
|
|
// if err := quick.Check(f, nil); err != nil {
|
||
|
|
// t.Error(err)
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
func Check(f any, config *Config) error {
|
||
|
|
if config == nil {
|
||
|
|
config = &defaultConfig
|
||
|
|
}
|
||
|
|
|
||
|
|
fVal, fType, ok := functionAndType(f)
|
||
|
|
if !ok {
|
||
|
|
return SetupError("argument is not a function")
|
||
|
|
}
|
||
|
|
|
||
|
|
if fType.NumOut() != 1 {
|
||
|
|
return SetupError("function does not return one value")
|
||
|
|
}
|
||
|
|
if fType.Out(0).Kind() != reflect.Bool {
|
||
|
|
return SetupError("function does not return a bool")
|
||
|
|
}
|
||
|
|
|
||
|
|
arguments := make([]reflect.Value, fType.NumIn())
|
||
|
|
rand := config.getRand()
|
||
|
|
maxCount := config.getMaxCount()
|
||
|
|
|
||
|
|
for i := 0; i < maxCount; i++ {
|
||
|
|
err := arbitraryValues(arguments, fType, config, rand)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
if !fVal.Call(arguments)[0].Bool() {
|
||
|
|
return &CheckError{i + 1, toInterfaces(arguments)}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// CheckEqual looks for an input on which f and g return different results.
|
||
|
|
// It calls f and g repeatedly with arbitrary values for each argument.
|
||
|
|
// If f and g return different answers, CheckEqual returns a *CheckEqualError
|
||
|
|
// describing the input and the outputs.
|
||
|
|
func CheckEqual(f, g any, config *Config) error {
|
||
|
|
if config == nil {
|
||
|
|
config = &defaultConfig
|
||
|
|
}
|
||
|
|
|
||
|
|
x, xType, ok := functionAndType(f)
|
||
|
|
if !ok {
|
||
|
|
return SetupError("f is not a function")
|
||
|
|
}
|
||
|
|
y, yType, ok := functionAndType(g)
|
||
|
|
if !ok {
|
||
|
|
return SetupError("g is not a function")
|
||
|
|
}
|
||
|
|
|
||
|
|
if xType != yType {
|
||
|
|
return SetupError("functions have different types")
|
||
|
|
}
|
||
|
|
|
||
|
|
arguments := make([]reflect.Value, xType.NumIn())
|
||
|
|
rand := config.getRand()
|
||
|
|
maxCount := config.getMaxCount()
|
||
|
|
|
||
|
|
for i := 0; i < maxCount; i++ {
|
||
|
|
err := arbitraryValues(arguments, xType, config, rand)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
xOut := toInterfaces(x.Call(arguments))
|
||
|
|
yOut := toInterfaces(y.Call(arguments))
|
||
|
|
|
||
|
|
if !reflect.DeepEqual(xOut, yOut) {
|
||
|
|
return &CheckEqualError{CheckError{i + 1, toInterfaces(arguments)}, xOut, yOut}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// arbitraryValues writes Values to args such that args contains Values
|
||
|
|
// suitable for calling f.
|
||
|
|
func arbitraryValues(args []reflect.Value, f reflect.Type, config *Config, rand *rand.Rand) (err error) {
|
||
|
|
if config.Values != nil {
|
||
|
|
config.Values(args, rand)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
for j := 0; j < len(args); j++ {
|
||
|
|
var ok bool
|
||
|
|
args[j], ok = Value(f.In(j), rand)
|
||
|
|
if !ok {
|
||
|
|
err = SetupError(fmt.Sprintf("cannot create arbitrary value of type %s for argument %d", f.In(j), j))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func functionAndType(f any) (v reflect.Value, t reflect.Type, ok bool) {
|
||
|
|
v = reflect.ValueOf(f)
|
||
|
|
ok = v.Kind() == reflect.Func
|
||
|
|
if !ok {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
t = v.Type()
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func toInterfaces(values []reflect.Value) []any {
|
||
|
|
ret := make([]any, len(values))
|
||
|
|
for i, v := range values {
|
||
|
|
ret[i] = v.Interface()
|
||
|
|
}
|
||
|
|
return ret
|
||
|
|
}
|
||
|
|
|
||
|
|
func toString(interfaces []any) string {
|
||
|
|
s := make([]string, len(interfaces))
|
||
|
|
for i, v := range interfaces {
|
||
|
|
s[i] = fmt.Sprintf("%#v", v)
|
||
|
|
}
|
||
|
|
return strings.Join(s, ", ")
|
||
|
|
}
|