// 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.package quick import ( "flag" "fmt" "math" "math/rand" "reflect" "strings") 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 integer taking half the range of an int64.func randInt64(rand *rand.Rand) int64 { return rand.Int63() - 1<<62 } // 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.Ptr: 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. If zero, the default is unchanged. MaxCountScale float64 // If non-nil, rand is a source of random numbers. Otherwise a default // pseudo-random source will be used. Rand *rand.Rand // If non-nil, the Values function generates a slice of arbitrary // reflect.Values that are congruent with the arguments to the function // being tested. Otherwise, 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(0)) } 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 []interface{}} 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 []interface{} Out2 []interface{}} 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 interface{}, config *Config) (err error) { if config == nil { config = &defaultConfig } fVal, fType, ok := functionAndType(f) if !ok { err = SetupError("argument is not a function") return } if fType.NumOut() != 1 { err = SetupError("function does not return one value") return } if fType.Out(0).Kind() != reflect.Bool { err = SetupError("function does not return a bool") return } 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 } if !fVal.Call(arguments)[0].Bool() { err = &CheckError{i + 1, toInterfaces(arguments)} return } } return} // 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 interface{}, config *Config) (err error) { if config == nil { config = &defaultConfig } x, xType, ok := functionAndType(f) if !ok { err = SetupError("f is not a function") return } y, yType, ok := functionAndType(g) if !ok { err = SetupError("g is not a function") return } if xType != yType { err = SetupError("functions have different types") return } 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 } xOut := toInterfaces(x.Call(arguments)) yOut := toInterfaces(y.Call(arguments)) if !reflect.DeepEqual(xOut, yOut) { err = &CheckEqualError{CheckError{i + 1, toInterfaces(arguments)}, xOut, yOut} return } } return} // 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 interface{}) (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) []interface{} { ret := make([]interface{}, len(values)) for i, v := range values { ret[i] = v.Interface() } return ret} func toString(interfaces []interface{}) string { s := make([]string, len(interfaces)) for i, v := range interfaces { s[i] = fmt.Sprintf("%#v", v) } return strings.Join(s, ", ")}
// 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.
package quick
import (
"flag"
"fmt"
"math"
"math/rand"
"reflect"
"strings"
)
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 integer taking half the range of an int64.
func randInt64(rand *rand.Rand) int64 { return rand.Int63() - 1<<62 }
// 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.Ptr:
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. If zero, the default is unchanged.
MaxCountScale float64
// If non-nil, rand is a source of random numbers. Otherwise a default
// pseudo-random source will be used.
Rand *rand.Rand
// If non-nil, the Values function generates a slice of arbitrary
// reflect.Values that are congruent with the arguments to the function
// being tested. Otherwise, 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(0))
}
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 []interface{}
}
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 []interface{}
Out2 []interface{}
}
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 interface{}, config *Config) (err error) {
if config == nil {
config = &defaultConfig
}
fVal, fType, ok := functionAndType(f)
if !ok {
err = SetupError("argument is not a function")
return
}
if fType.NumOut() != 1 {
err = SetupError("function does not return one value")
return
}
if fType.Out(0).Kind() != reflect.Bool {
err = SetupError("function does not return a bool")
return
}
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
}
if !fVal.Call(arguments)[0].Bool() {
err = &CheckError{i + 1, toInterfaces(arguments)}
return
}
}
return
}
// 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 interface{}, config *Config) (err error) {
if config == nil {
config = &defaultConfig
}
x, xType, ok := functionAndType(f)
if !ok {
err = SetupError("f is not a function")
return
}
y, yType, ok := functionAndType(g)
if !ok {
err = SetupError("g is not a function")
return
}
if xType != yType {
err = SetupError("functions have different types")
return
}
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
}
xOut := toInterfaces(x.Call(arguments))
yOut := toInterfaces(y.Call(arguments))
if !reflect.DeepEqual(xOut, yOut) {
err = &CheckEqualError{CheckError{i + 1, toInterfaces(arguments)}, xOut, yOut}
return
}
}
return
}
// 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 interface{}) (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) []interface{} {
ret := make([]interface{}, len(values))
for i, v := range values {
ret[i] = v.Interface()
}
return ret
}
func toString(interfaces []interface{}) string {
s := make([]string, len(interfaces))
for i, v := range interfaces {
s[i] = fmt.Sprintf("%#v", v)
}
return strings.Join(s, ", ")
}