package quick

Import Path
	testing/quick (on go.dev)

Dependency Relation
	imports 7 packages, and imported by 0 packages

Involved Source Files

	  d quick.go
		Package quick implements utility functions to help with black box testing.
		
		The testing/quick package is frozen and is not accepting new features.
Package-Level Type Names (total 5)

	/* sort by: alphabet | popularity */
	 type CheckEqualError (struct)
		A CheckEqualError is the result [CheckEqual] finding an error.

		Fields (total 5)
			CheckError CheckError
			CheckError.Count int
			CheckError.In []any
			Out1 []any
			Out2 []any
		Methods (only one)
			(*CheckEqualError) Error() string
		Implements (at least one exported)
			*CheckEqualError : error

	 type CheckError (struct)
		A CheckError is the result of Check finding an error.

		Fields (total 2)
			Count int
			In []any
		Methods (only one)
			(*CheckError) Error() string
		Implements (at least one exported)
			*CheckError : error

	 type Config (struct)
		A Config structure contains options for running a test.

		Fields (total 4)
			MaxCount int
				MaxCount sets the maximum number of iterations.
				If zero, MaxCountScale is used.

			MaxCountScale float64
				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.

			Rand *rand.Rand
				Rand specifies a source of random numbers.
				If nil, a default pseudo-random source will be used.

			Values func([]reflect.Value, *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.

		As Inputs Of (at least 2)
			func Check(f any, config *Config) error
			func CheckEqual(f, g any, config *Config) error

	 type Generator (interface)
		A Generator can generate random values of its own type.

		Methods (only one)
			( Generator) Generate(rand *rand.Rand, size int) reflect.Value
				Generate returns a random instance of the type on which it is a
				method using the size as a size hint.


	 type SetupError string (basic type)
		A SetupError is the result of an error in the way that check is being
		used, independent of the functions being tested.

		Methods (only one)
			( SetupError) Error() string
		Implements (at least one exported)
			 SetupError : error


Package-Level Functions (total 3)

	 func Check(f any, config *Config) error
		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 CheckEqual(f, g any, config *Config) error
		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 Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool)
		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.

The pages are generated with Golds v0.7.0-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.