QuickCheck-2.9.2: Automatic testing of Haskell programs

Safe Haskell | Safe
Language | Haskell98

Test.QuickCheck.Gen

Contents

- Generator type
- Primitive generator combinators
- Common generator combinators

Description

Test case generation.

Synopsis

- newtype Gen a = MkGen {
  - unGen :: QCGen -> Int -> a
  }
- variant :: Integral n => n -> Gen a -> Gen a
- sized :: (Int -> Gen a) -> Gen a
- resize :: Int -> Gen a -> Gen a
- scale :: (Int -> Int) -> Gen a -> Gen a
- choose :: Random a => (a, a) -> Gen a
- chooseAny :: Random a => Gen a
- generate :: Gen a -> IO a
- sample' :: Gen a -> IO [a]
- sample :: Show a => Gen a -> IO ()
- suchThat :: Gen a -> (a -> Bool) -> Gen a
- suchThatMaybe :: Gen a -> (a -> Bool) -> Gen (Maybe a)
- oneof :: [Gen a] -> Gen a
- frequency :: [(Int, Gen a)] -> Gen a
- elements :: [a] -> Gen a
- sublistOf :: [a] -> Gen [a]
- shuffle :: [a] -> Gen [a]
- growingElements :: [a] -> Gen a
- listOf :: Gen a -> Gen [a]
- listOf1 :: Gen a -> Gen [a]
- vectorOf :: Int -> Gen a -> Gen [a]
- infiniteListOf :: Gen a -> Gen [a]

## Generator type

newtype Gen a #

A generator for values of type `a`.

Constructors

MkGen |
Fields unGen :: QCGen -> Int -> a Run the generator on a particular seed. If you just want to get a random value out, consider using `generate`.

Instances

Monad Gen # |
Methods (>>=) :: Gen a -> (a -> Gen b) -> Gen b # (>>) :: Gen a -> Gen b -> Gen b # return :: a -> Gen a # fail :: String -> Gen a #
Functor Gen # |
Methods fmap :: (a -> b) -> Gen a -> Gen b # (<$) :: a -> Gen b -> Gen a #
Applicative Gen # |
Methods pure :: a -> Gen a # (<*>) :: Gen (a -> b) -> Gen a -> Gen b # (*>) :: Gen a -> Gen b -> Gen b # (<*) :: Gen a -> Gen b -> Gen a #
Testable prop => Testable (Gen prop) # |
Methods property :: Gen prop -> Property #

## Primitive generator combinators

variant :: Integral n => n -> Gen a -> Gen a #

Modifies a generator using an integer seed.

sized :: (Int -> Gen a) -> Gen a #

Used to construct generators that depend on the size parameter.

resize :: Int -> Gen a -> Gen a #

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

scale :: (Int -> Int) -> Gen a -> Gen a #

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

choose :: Random a => (a, a) -> Gen a #

Generates a random element in the given inclusive range.

chooseAny :: Random a => Gen a #

Generates a random element over the natural range of `a`.

generate :: Gen a -> IO a #

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

sample' :: Gen a -> IO [a] #

Generates some example values.

sample :: Show a => Gen a -> IO () #

Generates some example values and prints them to `stdout`.

## Common generator combinators

suchThat :: Gen a -> (a -> Bool) -> Gen a #

Generates a value that satisfies a predicate.

suchThatMaybe :: Gen a -> (a -> Bool) -> Gen (Maybe a) #

Tries to generate a value that satisfies a predicate.

oneof :: [Gen a] -> Gen a #

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

frequency :: [(Int, Gen a)] -> Gen a #

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

elements :: [a] -> Gen a #

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

sublistOf :: [a] -> Gen [a] #

Generates a random subsequence of the given list.

shuffle :: [a] -> Gen [a] #

Generates a random permutation of the given list.

growingElements :: [a] -> Gen a #

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.

listOf :: Gen a -> Gen [a] #

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

listOf1 :: Gen a -> Gen [a] #

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

vectorOf :: Int -> Gen a -> Gen [a] #

Generates a list of the given length.

infiniteListOf :: Gen a -> Gen [a] #

Generates an infinite list.