1 files changed, 0 insertions, 358 deletions
diff --git a/src/pkg/testing/quick/quick.go b/src/pkg/testing/quick/quick.go
deleted file mode 100644
index bc79cc329..000000000
--- a/src/pkg/testing/quick/quick.go
+++ /dev/null
@@ -1,358 +0,0 @@
-// 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) {
-	if m, ok := reflect.Zero(t).Interface().(Generator); ok {
-		return m.Generate(rand, complexSize), 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(complexSize)
-		v.Set(reflect.MakeMap(concrete))
-		for i := 0; i < numElems; i++ {
-			key, ok1 := Value(concrete.Key(), rand)
-			value, ok2 := Value(concrete.Elem(), rand)
-			if !ok1 || !ok2 {
-				return reflect.Value{}, false
-			}
-			v.SetMapIndex(key, value)
-		}
-	case reflect.Ptr:
-		elem, ok := Value(concrete.Elem(), rand)
-		if !ok {
-			return reflect.Value{}, false
-		}
-		v.Set(reflect.New(concrete.Elem()))
-		v.Elem().Set(elem)
-	case reflect.Slice:
-		numElems := rand.Intn(complexSize)
-		v.Set(reflect.MakeSlice(concrete, numElems, numElems))
-		for i := 0; i < numElems; i++ {
-			elem, ok := Value(concrete.Elem(), rand)
-			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:
-		for i := 0; i < v.NumField(); i++ {
-			elem, ok := Value(concrete.Field(i).Type, rand)
-			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 Values 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(function interface{}, config *Config) (err error) {
-	if config == nil {
-		config = &defaultConfig
-	}
-
-	f, fType, ok := functionAndType(function)
-	if !ok {
-		err = SetupError("argument is not a function")
-		return
-	}
-
-	if fType.NumOut() != 1 {
-		err = SetupError("function returns more than 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 !f.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, ", ")
-}