Tests a property and prints the results to stdout.

By default up to 100 tests are performed, which may not be enough to find all bugs. To run more tests, use withMaxSuccess.

Args specifies arguments to the QuickCheck driver

Result represents the test result

The default test arguments

Tests a property, using test arguments, and prints the results to stdout.

Tests a property, using test arguments, produces a test result, and prints the results to stdout.

Tests a property, produces a test result, and prints the results to stdout.

Tests a property and prints the results and all test cases generated to stdout. This is just a convenience function that means the same as quickCheck . verbose.

Tests a property, using test arguments, and prints the results and all test cases generated to stdout. This is just a convenience function that combines quickCheckWith and verbose.

Tests a property, using test arguments, produces a test result, and prints the results and all test cases generated to stdout. This is just a convenience function that combines quickCheckWithResult and verbose.

Tests a property, produces a test result, and prints the results and all test cases generated to stdout. This is just a convenience function that combines quickCheckResult and verbose.

Test all properties in the current module. The name of the property must begin with prop_. Polymorphic properties will be defaulted to Integer. Returns True if all tests succeeded, False otherwise.

To use quickCheckAll, add a definition to your module along the lines of

return []
runTests = $quickCheckAll

and then execute runTests.

Note: the bizarre return [] in the example above is needed on GHC 7.8 and later; without it, quickCheckAll will not be able to find any of the properties. For the curious, the return [] is a Template Haskell splice that makes GHC insert the empty list of declarations at that point in the program; GHC typechecks everything before the return [] before it starts on the rest of the module, which means that the later call to quickCheckAll can see everything that was defined before the return []. Yikes!

Test all properties in the current module. This is just a convenience function that combines quickCheckAll and verbose.

verboseCheckAll has the same issue with scoping as quickCheckAll: see the note there about return [].

Test all properties in the current module, using a custom quickCheck function. The same caveats as with quickCheckAll apply.

$forAllProperties has type (Property -> IO Result) -> IO Bool. An example invocation is $forAllProperties quickCheckResult, which does the same thing as $quickCheckAll.

forAllProperties has the same issue with scoping as quickCheckAll: see the note there about return [].

List all properties in the current module.

$allProperties has type [(String, Property)].

allProperties has the same issue with scoping as quickCheckAll: see the note there about return [].

Test a polymorphic property, defaulting all type variables to Integer.

Invoke as $(polyQuickCheck 'prop), where prop is a property. Note that just evaluating quickCheck prop in GHCi will seem to work, but will silently default all type variables to ()!

$(polyQuickCheck 'prop) means the same as quickCheck $(monomorphic 'prop). If you want to supply custom arguments to polyQuickCheck, you will have to combine quickCheckWith and monomorphic yourself.

If you want to use polyQuickCheck in the same file where you defined the property, the same scoping problems pop up as in quickCheckAll: see the note there about return [].

Test a polymorphic property, defaulting all type variables to Integer. This is just a convenience function that combines verboseCheck and monomorphic.

If you want to use polyVerboseCheck in the same file where you defined the property, the same scoping problems pop up as in quickCheckAll: see the note there about return [].

Monomorphise an arbitrary property by defaulting all type variables to Integer.

For example, if f has type Ord a => [a] -> [a] then $(monomorphic 'f) has type [Integer] -> [Integer].

If you want to use monomorphic in the same file where you defined the property, the same scoping problems pop up as in quickCheckAll: see the note there about return [].

Random generation and shrinking of values.

QuickCheck provides Arbitrary instances for most types in base, except those which incur extra dependencies. For a wider range of Arbitrary instances see the quickcheck-instances package.

Shrink a term to any of its immediate subterms, and also recursively shrink all subterms.

All immediate subterms of a term.

Recursively shrink all immediate subterms.

Returns no shrinking alternatives.

Shrink a list of values given a shrinking function for individual values.

Map a shrink function to another domain. This is handy if your data type has special invariants, but is almost isomorphic to some other type.

shrinkOrderedList :: (Ord a, Arbitrary a) => [a] -> [[a]]
shrinkOrderedList = shrinkMap sort id

shrinkSet :: (Ord a, Arbitrary a) => Set a -> Set [a]
shrinkSet = shrinkMap fromList toList

Non-overloaded version of shrinkMap.

Shrink an integral number.

Shrink a fraction, via continued-fraction approximations.

Lifting of the Arbitrary class to unary type constructors.

Lifting of the Arbitrary class to binary type constructors.

A generator for values of type a.

The third-party package QuickCheck-GenT provides a monad transformer version of GenT.

Generates a random element in the given inclusive range.

Randomly uses one of the given generators. The input list must be non-empty.

Chooses one of the given generators, with a weighted random distribution. The input list must be non-empty.

Generates one of the given values. The input list must be non-empty.

Takes a list of elements of increasing size, and chooses among an initial segment of the list. The size of this initial segment increases with the size parameter. The input list must be non-empty.

Used to construct generators that depend on the size parameter.

For example, listOf, which uses the size parameter as an upper bound on length of lists it generates, can be defined like this:

listOf :: Gen a -> Gen [a]
listOf gen = sized $ \n ->
  do k <- choose (0,n)
     vectorOf k gen

You can also do this using getSize.

Returns the size parameter. Used to construct generators that depend on the size parameter.

For example, listOf, which uses the size parameter as an upper bound on length of lists it generates, can be defined like this:

listOf :: Gen a -> Gen [a]
listOf gen = do
  n <- getSize
  k <- choose (0,n)
  vectorOf k gen

You can also do this using sized.

Overrides the size parameter. Returns a generator which uses the given size instead of the runtime-size parameter.

Adjust the size parameter, by transforming it with the given function.

Generates a value that satisfies a predicate.

Generates a value for which the given function returns a Just, and then applies the function.

Tries to generate a value that satisfies a predicate. If it fails to do so after enough attempts, returns Nothing.

Apply a binary function to random arguments.

Apply a ternary function to random arguments.

Apply a function of arity 4 to random arguments.

Generates a list of random length. The maximum length depends on the size parameter.

Generates a non-empty list of random length. The maximum length depends on the size parameter.

Generates a list of the given length.

Generates a list of a given length.

Generates an infinite list.

Generates an infinite list.

Generates a random permutation of the given list.

Generates a random subsequence of the given list.

Generates an ordered list.

Generates an integral number. The number can be positive or negative and its maximum absolute value depends on the size parameter.

Generates a natural number. The number's maximum value depends on the size parameter.

Generates a fractional number. The number can be positive or negative and its maximum absolute value depends on the size parameter.

Generates an integral number from a bounded domain. The number is chosen from the entire range of the type, but small numbers are generated more often than big numbers. Inspired by demands from Phil Wadler.

Generates an integral number. The number is chosen uniformly from the entire range of the type. You may want to use arbitrarySizedBoundedIntegral instead.

Generates an element of a bounded type. The element is chosen from the entire range of the type.

Generates an element of a bounded enumeration.

Generates any Unicode character (but not a surrogate)

Generates a random ASCII character (0-127).

Generates a printable Unicode character.

Run a generator. The size passed to the generator is always 30; if you want another size then you should explicitly use resize.

Generates some example values and prints them to stdout.

Generates some example values.

Generation of random shrinkable, showable functions.

To generate random values of type Fun a b, you must have an instance Function a.

See also applyFun, and Fn with GHC >= 7.8.

Extracts the value of a function.

Fn is the pattern equivalent of this function.

prop :: Fun String Integer -> Bool
prop f = applyFun f "banana" == applyFun f "monkey"
      || applyFun f "banana" == applyFun f "elephant"

Extracts the value of a binary function.

Fn2 is the pattern equivalent of this function.

prop_zipWith :: Fun (Int, Bool) Char -> [Int] -> [Bool] -> Bool
prop_zipWith f xs ys = zipWith (applyFun2 f) xs ys == [ applyFun2 f x y | (x, y) <- zip xs ys]

Extracts the value of a ternary function. Fn3 is the pattern equivalent of this function.

A modifier for testing functions.

prop :: Fun String Integer -> Bool
prop (Fn f) = f "banana" == f "monkey"
           || f "banana" == f "elephant"

A modifier for testing binary functions.

prop_zipWith :: Fun (Int, Bool) Char -> [Int] -> [Bool] -> Bool
prop_zipWith (Fn2 f) xs ys = zipWith f xs ys == [ f x y | (x, y) <- zip xs ys]

A modifier for testing ternary functions.

The class Function a is used for random generation of showable functions of type a -> b.

There is a default implementation for function, which you can use if your type has structural equality. Otherwise, you can normally use functionMap or functionShow.

The basic building block for Function instances. Provides a Function instance by mapping to and from a type that already has a Function instance.

Provides a Function instance for types with Show and Read.

Provides a Function instance for types with Integral.

Provides a Function instance for types with RealFrac.

Provides a Function instance for types with Bounded and Enum. Use only for small types (i.e. not integers): creates the list ['minBound'..'maxBound']!

Used for random generation of functions. You should consider using Fun instead, which can show the generated functions as strings.

If you are using a recent GHC, there is a default definition of coarbitrary using genericCoarbitrary, so if your type has a Generic instance it's enough to say

instance CoArbitrary MyType

You should only use genericCoarbitrary for data types where equality is structural, i.e. if you can't have two different representations of the same value. An example where it's not safe is sets implemented using binary search trees: the same set can be represented as several different trees. Here you would have to explicitly define coarbitrary s = coarbitrary (toList s).