tasty-quickcheck-0.10.1: QuickCheck support for the Tasty test framework.

Safe Haskell | None
Language | Haskell2010

Test.Tasty.QuickCheck

Contents

- Internal

Description

This module allows to use QuickCheck properties in tasty.

Synopsis

- testProperty :: Testable a => TestName -> a -> TestTree
- testProperties :: TestName -> [(String, Property)] -> TestTree
- newtype QuickCheckTests = QuickCheckTests Int
- newtype QuickCheckReplay = QuickCheckReplay (Maybe Int)
- newtype QuickCheckShowReplay = QuickCheckShowReplay Bool
- newtype QuickCheckMaxSize = QuickCheckMaxSize Int
- newtype QuickCheckMaxRatio = QuickCheckMaxRatio Int
- newtype QuickCheckVerbose = QuickCheckVerbose Bool
- labelledExamplesWithResult :: Testable prop => Args -> prop -> IO Result
- labelledExamplesResult :: Testable prop => prop -> IO Result
- labelledExamplesWith :: Testable prop => Args -> prop -> IO ()
- labelledExamples :: Testable prop => prop -> IO ()
- monomorphic :: Name -> ExpQ
- polyVerboseCheck :: Name -> ExpQ
- polyQuickCheck :: Name -> ExpQ
- isSuccess :: Result -> Bool
- pattern Success :: Int -> Int -> !(Map [String] Int) -> !(Map String Int) -> !(Map String (Map String Int)) -> String -> Result
- pattern GaveUp :: Int -> Int -> !(Map [String] Int) -> !(Map String Int) -> !(Map String (Map String Int)) -> String -> Result
- pattern Failure :: Int -> Int -> Int -> Int -> Int -> QCGen -> Int -> String -> Maybe AnException -> String -> [String] -> [String] -> Set String -> Result
- pattern NoExpectedFailure :: Int -> Int -> !(Map [String] Int) -> !(Map String Int) -> !(Map String (Map String Int)) -> String -> Result
- numTests :: Result -> Int
- numDiscarded :: Result -> Int
- labels :: Result -> Map [String] Int
- classes :: Result -> Map String Int
- tables :: Result -> Map String (Map String Int)
- output :: Result -> String
- numShrinks :: Result -> Int
- numShrinkTries :: Result -> Int
- numShrinkFinal :: Result -> Int
- usedSeed :: Result -> QCGen
- usedSize :: Result -> Int
- reason :: Result -> String
- theException :: Result -> Maybe AnException
- failingTestCase :: Result -> [String]
- failingLabels :: Result -> [String]
- failingClasses :: Result -> Set String
- total :: NFData a => a -> Property
- (=/=) :: (Eq a, Show a) => a -> a -> Property
- (===) :: (Eq a, Show a) => a -> a -> Property
- disjoin :: Testable prop => [prop] -> Property
- (.||.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property
- conjoin :: Testable prop => [prop] -> Property
- (.&&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property
- (.&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property
- forAllShrinkBlind :: Testable prop => Gen a -> (a -> [a]) -> (a -> prop) -> Property
- forAllShrinkShow :: Testable prop => Gen a -> (a -> [a]) -> (a -> String) -> (a -> prop) -> Property
- forAllShrink :: (Show a, Testable prop) => Gen a -> (a -> [a]) -> (a -> prop) -> Property
- forAllBlind :: Testable prop => Gen a -> (a -> prop) -> Property
- forAllShow :: Testable prop => Gen a -> (a -> String) -> (a -> prop) -> Property
- forAll :: (Show a, Testable prop) => Gen a -> (a -> prop) -> Property
- within :: Testable prop => Int -> prop -> Property
- (==>) :: Testable prop => Bool -> prop -> Property
- coverTable :: Testable prop => String -> [(String, Double)] -> prop -> Property
- tabulate :: Testable prop => String -> [String] -> prop -> Property
- cover :: Testable prop => Double -> Bool -> String -> prop -> Property
- classify :: Testable prop => Bool -> String -> prop -> Property
- collect :: (Show a, Testable prop) => a -> prop -> Property
- label :: Testable prop => String -> prop -> Property
- stdConfidence :: Confidence
- checkCoverageWith :: Testable prop => Confidence -> prop -> Property
- checkCoverage :: Testable prop => prop -> Property
- withMaxSuccess :: Testable prop => Int -> prop -> Property
- again :: Testable prop => prop -> Property
- once :: Testable prop => prop -> Property
- expectFailure :: Testable prop => prop -> Property
- verboseShrinking :: Testable prop => prop -> Property
- whenFail' :: Testable prop => IO () -> prop -> Property
- whenFail :: Testable prop => IO () -> prop -> Property
- printTestCase :: Testable prop => String -> prop -> Property
- counterexample :: Testable prop => String -> prop -> Property
- noShrinking :: Testable prop => prop -> Property
- shrinking :: Testable prop => (a -> [a]) -> a -> (a -> prop) -> Property
- mapSize :: Testable prop => (Int -> Int) -> prop -> Property
- idempotentIOProperty :: Testable prop => IO prop -> Property
- ioProperty :: Testable prop => IO prop -> Property
- data Property
- class Testable prop where
  - property :: prop -> Property
- data Discard = Discard
- data Confidence = Confidence {
  - certainty :: Integer
  - tolerance :: Double
  }
- applyFun3 :: Fun (a, b, c) d -> a -> b -> c -> d
- applyFun2 :: Fun (a, b) c -> a -> b -> c
- applyFun :: Fun a b -> a -> b
- functionMap :: Function b => (a -> b) -> (b -> a) -> (a -> c) -> a :-> c
- functionShow :: (Show a, Read a) => (a -> c) -> a :-> c
- functionIntegral :: Integral a => (a -> b) -> a :-> b
- functionRealFrac :: RealFrac a => (a -> b) -> a :-> b
- functionBoundedEnum :: (Eq a, Bounded a, Enum a) => (a -> b) -> a :-> b
- pattern Fn :: forall a b. (a -> b) -> Fun a b
- pattern Fn2 :: forall a b c. (a -> b -> c) -> Fun (a, b) c
- pattern Fn3 :: forall a b c d. (a -> b -> c -> d) -> Fun (a, b, c) d
- class Function a where
  - function :: (a -> b) -> a :-> b
- data Fun a b = Fun (a :-> b, b, Shrunk) (a -> b)
- newtype Blind a = Blind {
  - getBlind :: a
  }
- newtype Fixed a = Fixed {
  - getFixed :: a
  }
- newtype OrderedList a = Ordered {
  - getOrdered :: [a]
  }
- newtype NonEmptyList a = NonEmpty {
  - getNonEmpty :: [a]
  }
- data InfiniteList a = InfiniteList {
  - getInfiniteList :: [a]
  - infiniteListInternalData :: InfiniteListInternalData a
  }
- newtype SortedList a = Sorted {
  - getSorted :: [a]
  }
- newtype Positive a = Positive {
  - getPositive :: a
  }
- newtype NonZero a = NonZero {
  - getNonZero :: a
  }
- newtype NonNegative a = NonNegative {
  - getNonNegative :: a
  }
- newtype Large a = Large {
  - getLarge :: a
  }
- newtype Small a = Small {
  - getSmall :: a
  }
- newtype Shrink2 a = Shrink2 {
  - getShrink2 :: a
  }
- data Smart a = Smart Int a
- data Shrinking s a = Shrinking s a
- class ShrinkState s a where
  - shrinkInit :: a -> s
  - shrinkState :: a -> s -> [(a, s)]
- newtype ASCIIString = ASCIIString {
  - getASCIIString :: String
  }
- newtype UnicodeString = UnicodeString {
  - getUnicodeString :: String
  }
- newtype PrintableString = PrintableString {
  - getPrintableString :: String
  }
- infiniteList :: Arbitrary a => Gen [a]
- orderedList :: (Ord a, Arbitrary a) => Gen [a]
- vector :: Arbitrary a => Int -> Gen [a]
- coarbitraryEnum :: Enum a => a -> Gen b -> Gen b
- coarbitraryShow :: Show a => a -> Gen b -> Gen b
- coarbitraryReal :: Real a => a -> Gen b -> Gen b
- coarbitraryIntegral :: Integral a => a -> Gen b -> Gen b
- (><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> Gen a -> Gen a
- genericCoarbitrary :: (Generic a, GCoArbitrary (Rep a)) => a -> Gen b -> Gen b
- shrinkDecimal :: RealFrac a => a -> [a]
- shrinkRealFrac :: RealFrac a => a -> [a]
- shrinkIntegral :: Integral a => a -> [a]
- shrinkMapBy :: (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b]
- shrinkMap :: Arbitrary a => (a -> b) -> (b -> a) -> b -> [b]
- shrinkNothing :: a -> [a]
- arbitraryPrintableChar :: Gen Char
- arbitraryASCIIChar :: Gen Char
- arbitraryUnicodeChar :: Gen Char
- arbitrarySizedBoundedIntegral :: (Bounded a, Integral a) => Gen a
- arbitraryBoundedEnum :: (Bounded a, Enum a) => Gen a
- arbitraryBoundedRandom :: (Bounded a, Random a) => Gen a
- arbitraryBoundedIntegral :: (Bounded a, Integral a) => Gen a
- arbitrarySizedFractional :: Fractional a => Gen a
- arbitrarySizedNatural :: Integral a => Gen a
- arbitrarySizedIntegral :: Integral a => Gen a
- applyArbitrary4 :: (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => (a -> b -> c -> d -> r) -> Gen r
- applyArbitrary3 :: (Arbitrary a, Arbitrary b, Arbitrary c) => (a -> b -> c -> r) -> Gen r
- applyArbitrary2 :: (Arbitrary a, Arbitrary b) => (a -> b -> r) -> Gen r
- shrinkList :: (a -> [a]) -> [a] -> [[a]]
- subterms :: (Generic a, GSubterms (Rep a) a) => a -> [a]
- recursivelyShrink :: (Generic a, RecursivelyShrink (Rep a)) => a -> [a]
- genericShrink :: (Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) => a -> [a]
- shrink2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => f a b -> [f a b]
- arbitrary2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => Gen (f a b)
- shrink1 :: (Arbitrary1 f, Arbitrary a) => f a -> [f a]
- arbitrary1 :: (Arbitrary1 f, Arbitrary a) => Gen (f a)
- class Arbitrary a where
  - arbitrary :: Gen a
  - shrink :: a -> [a]
- class Arbitrary1 (f :: Type -> Type) where
  - liftArbitrary :: Gen a -> Gen (f a)
  - liftShrink :: (a -> [a]) -> f a -> [f a]
- class Arbitrary2 (f :: Type -> Type -> Type) where
  - liftArbitrary2 :: Gen a -> Gen b -> Gen (f a b)
  - liftShrink2 :: (a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
- class CoArbitrary a where
  - coarbitrary :: a -> Gen b -> Gen b
- infiniteListOf :: Gen a -> Gen [a]
- vectorOf :: Int -> Gen a -> Gen [a]
- listOf1 :: Gen a -> Gen [a]
- listOf :: Gen a -> Gen [a]
- growingElements :: [a] -> Gen a
- shuffle :: [a] -> Gen [a]
- sublistOf :: [a] -> Gen [a]
- elements :: [a] -> Gen a
- frequency :: [(Int, Gen a)] -> Gen a
- oneof :: [Gen a] -> Gen a
- suchThatMaybe :: Gen a -> (a -> Bool) -> Gen (Maybe a)
- suchThatMap :: Gen a -> (a -> Maybe b) -> Gen b
- suchThat :: Gen a -> (a -> Bool) -> Gen a
- sample :: Show a => Gen a -> IO ()
- sample' :: Gen a -> IO [a]
- generate :: Gen a -> IO a
- choose :: Random a => (a, a) -> Gen a
- scale :: (Int -> Int) -> Gen a -> Gen a
- resize :: Int -> Gen a -> Gen a
- getSize :: Gen Int
- sized :: (Int -> Gen a) -> Gen a
- variant :: Integral n => n -> Gen a -> Gen a
- data Gen a
- discard :: a
- newtype QC = QC Property
- optionSetToArgs :: OptionSet -> IO (Int, Args)

# Documentation

testProperty :: Testable a => TestName -> a -> TestTree Source #

Create a `Test` for a QuickCheck `Testable` property

testProperties :: TestName -> [(String, Property)] -> TestTree Source #

Create a test from a list of QuickCheck properties. To be used with `allProperties`. E.g.

    tests :: TestTree
    tests = testProperties "Foo" $allProperties

newtype QuickCheckTests Source #

Number of test cases for QuickCheck to generate

Constructors

QuickCheckTests Int |

Instances

Enum QuickCheckTests Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

succ :: QuickCheckTests -> QuickCheckTests Source #

pred :: QuickCheckTests -> QuickCheckTests Source #

toEnum :: Int -> QuickCheckTests Source #

fromEnum :: QuickCheckTests -> Int Source #

enumFrom :: QuickCheckTests -> [QuickCheckTests] Source #

enumFromThen :: QuickCheckTests -> QuickCheckTests -> [QuickCheckTests] Source #

enumFromTo :: QuickCheckTests -> QuickCheckTests -> [QuickCheckTests] Source #

enumFromThenTo :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests -> [QuickCheckTests] Source #

Eq QuickCheckTests Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods (==) :: QuickCheckTests -> QuickCheckTests -> Bool Source # (/=) :: QuickCheckTests -> QuickCheckTests -> Bool Source #
Integral QuickCheckTests Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

quot :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

rem :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

div :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

mod :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

quotRem :: QuickCheckTests -> QuickCheckTests -> (QuickCheckTests, QuickCheckTests) Source #

divMod :: QuickCheckTests -> QuickCheckTests -> (QuickCheckTests, QuickCheckTests) Source #

toInteger :: QuickCheckTests -> Integer Source #

Num QuickCheckTests Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

(+) :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

(-) :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

(*) :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

negate :: QuickCheckTests -> QuickCheckTests Source #

abs :: QuickCheckTests -> QuickCheckTests Source #

signum :: QuickCheckTests -> QuickCheckTests Source #

fromInteger :: Integer -> QuickCheckTests Source #

Ord QuickCheckTests Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

compare :: QuickCheckTests -> QuickCheckTests -> Ordering Source #

(<) :: QuickCheckTests -> QuickCheckTests -> Bool Source #

(<=) :: QuickCheckTests -> QuickCheckTests -> Bool Source #

(>) :: QuickCheckTests -> QuickCheckTests -> Bool Source #

(>=) :: QuickCheckTests -> QuickCheckTests -> Bool Source #

max :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

min :: QuickCheckTests -> QuickCheckTests -> QuickCheckTests Source #

Real QuickCheckTests Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods toRational :: QuickCheckTests -> Rational Source #
IsOption QuickCheckTests Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods defaultValue :: QuickCheckTests Source # parseValue :: String -> Maybe QuickCheckTests Source # optionName :: Tagged QuickCheckTests String Source # optionHelp :: Tagged QuickCheckTests String Source # optionCLParser :: Parser QuickCheckTests Source #

newtype QuickCheckReplay Source #

Constructors

QuickCheckReplay (Maybe Int) |

Instances

IsOption QuickCheckReplay Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods defaultValue :: QuickCheckReplay Source # parseValue :: String -> Maybe QuickCheckReplay Source # optionName :: Tagged QuickCheckReplay String Source # optionHelp :: Tagged QuickCheckReplay String Source # optionCLParser :: Parser QuickCheckReplay Source #

newtype QuickCheckShowReplay Source #

If a test case fails unexpectedly, show the replay token

Constructors

QuickCheckShowReplay Bool |

Instances

IsOption QuickCheckShowReplay Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods defaultValue :: QuickCheckShowReplay Source # parseValue :: String -> Maybe QuickCheckShowReplay Source # optionName :: Tagged QuickCheckShowReplay String Source # optionHelp :: Tagged QuickCheckShowReplay String Source # optionCLParser :: Parser QuickCheckShowReplay Source #

newtype QuickCheckMaxSize Source #

Size of the biggest test cases

Constructors

QuickCheckMaxSize Int |

Instances

Enum QuickCheckMaxSize Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

succ :: QuickCheckMaxSize -> QuickCheckMaxSize Source #

pred :: QuickCheckMaxSize -> QuickCheckMaxSize Source #

toEnum :: Int -> QuickCheckMaxSize Source #

fromEnum :: QuickCheckMaxSize -> Int Source #

enumFrom :: QuickCheckMaxSize -> [QuickCheckMaxSize] Source #

enumFromThen :: QuickCheckMaxSize -> QuickCheckMaxSize -> [QuickCheckMaxSize] Source #

enumFromTo :: QuickCheckMaxSize -> QuickCheckMaxSize -> [QuickCheckMaxSize] Source #

enumFromThenTo :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize -> [QuickCheckMaxSize] Source #

Eq QuickCheckMaxSize Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods (==) :: QuickCheckMaxSize -> QuickCheckMaxSize -> Bool Source # (/=) :: QuickCheckMaxSize -> QuickCheckMaxSize -> Bool Source #
Integral QuickCheckMaxSize Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

quot :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

rem :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

div :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

mod :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

quotRem :: QuickCheckMaxSize -> QuickCheckMaxSize -> (QuickCheckMaxSize, QuickCheckMaxSize) Source #

divMod :: QuickCheckMaxSize -> QuickCheckMaxSize -> (QuickCheckMaxSize, QuickCheckMaxSize) Source #

toInteger :: QuickCheckMaxSize -> Integer Source #

Num QuickCheckMaxSize Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

(+) :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

(-) :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

(*) :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

negate :: QuickCheckMaxSize -> QuickCheckMaxSize Source #

abs :: QuickCheckMaxSize -> QuickCheckMaxSize Source #

signum :: QuickCheckMaxSize -> QuickCheckMaxSize Source #

fromInteger :: Integer -> QuickCheckMaxSize Source #

Ord QuickCheckMaxSize Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

compare :: QuickCheckMaxSize -> QuickCheckMaxSize -> Ordering Source #

(<) :: QuickCheckMaxSize -> QuickCheckMaxSize -> Bool Source #

(<=) :: QuickCheckMaxSize -> QuickCheckMaxSize -> Bool Source #

(>) :: QuickCheckMaxSize -> QuickCheckMaxSize -> Bool Source #

(>=) :: QuickCheckMaxSize -> QuickCheckMaxSize -> Bool Source #

max :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

min :: QuickCheckMaxSize -> QuickCheckMaxSize -> QuickCheckMaxSize Source #

Real QuickCheckMaxSize Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods toRational :: QuickCheckMaxSize -> Rational Source #
IsOption QuickCheckMaxSize Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods defaultValue :: QuickCheckMaxSize Source # parseValue :: String -> Maybe QuickCheckMaxSize Source # optionName :: Tagged QuickCheckMaxSize String Source # optionHelp :: Tagged QuickCheckMaxSize String Source # optionCLParser :: Parser QuickCheckMaxSize Source #

newtype QuickCheckMaxRatio Source #

Maximum number of of discarded tests per successful test before giving up.

Constructors

QuickCheckMaxRatio Int |

Instances

Enum QuickCheckMaxRatio Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

succ :: QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

pred :: QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

toEnum :: Int -> QuickCheckMaxRatio Source #

fromEnum :: QuickCheckMaxRatio -> Int Source #

enumFrom :: QuickCheckMaxRatio -> [QuickCheckMaxRatio] Source #

enumFromThen :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> [QuickCheckMaxRatio] Source #

enumFromTo :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> [QuickCheckMaxRatio] Source #

enumFromThenTo :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio -> [QuickCheckMaxRatio] Source #

Eq QuickCheckMaxRatio Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods (==) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> Bool Source # (/=) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> Bool Source #
Integral QuickCheckMaxRatio Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

quot :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

rem :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

div :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

mod :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

quotRem :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> (QuickCheckMaxRatio, QuickCheckMaxRatio) Source #

divMod :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> (QuickCheckMaxRatio, QuickCheckMaxRatio) Source #

toInteger :: QuickCheckMaxRatio -> Integer Source #

Num QuickCheckMaxRatio Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

(+) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

(-) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

(*) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

negate :: QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

abs :: QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

signum :: QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

fromInteger :: Integer -> QuickCheckMaxRatio Source #

Ord QuickCheckMaxRatio Source # |

Instance details

Defined in Test.Tasty.QuickCheck

Methods

compare :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> Ordering Source #

(<) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> Bool Source #

(<=) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> Bool Source #

(>) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> Bool Source #

(>=) :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> Bool Source #

max :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

min :: QuickCheckMaxRatio -> QuickCheckMaxRatio -> QuickCheckMaxRatio Source #

Real QuickCheckMaxRatio Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods toRational :: QuickCheckMaxRatio -> Rational Source #
IsOption QuickCheckMaxRatio Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods defaultValue :: QuickCheckMaxRatio Source # parseValue :: String -> Maybe QuickCheckMaxRatio Source # optionName :: Tagged QuickCheckMaxRatio String Source # optionHelp :: Tagged QuickCheckMaxRatio String Source # optionCLParser :: Parser QuickCheckMaxRatio Source #

newtype QuickCheckVerbose Source #

Show the test cases that QuickCheck generates

Constructors

QuickCheckVerbose Bool |

Instances

IsOption QuickCheckVerbose Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods defaultValue :: QuickCheckVerbose Source # parseValue :: String -> Maybe QuickCheckVerbose Source # optionName :: Tagged QuickCheckVerbose String Source # optionHelp :: Tagged QuickCheckVerbose String Source # optionCLParser :: Parser QuickCheckVerbose Source #

labelledExamplesWithResult :: Testable prop => Args -> prop -> IO Result Source #

A variant of `labelledExamples` that takes test arguments and returns a result.

labelledExamplesResult :: Testable prop => prop -> IO Result Source #

A variant of `labelledExamples` that returns a result.

labelledExamplesWith :: Testable prop => Args -> prop -> IO () Source #

A variant of `labelledExamples` that takes test arguments.

labelledExamples :: Testable prop => prop -> IO () Source #

Given a property, which must use `label`, `collect`, `classify` or `cover` to associate labels with test cases, find an example test case for each possible label. The example test cases are minimised using shrinking.

For example, suppose we test ``delete` x xs` and record the number of times that `x` occurs in `xs`:

    prop_delete :: Int -> [Int] -> Property
    prop_delete x xs =
      classify (count x xs == 0) "count x xs == 0" $
      classify (count x xs == 1) "count x xs == 1" $
      classify (count x xs >= 2) "count x xs >= 2" $
      counterexample (show (delete x xs)) $
      count x (delete x xs) == max 0 (count x xs-1)
      where count x xs = length (filter (== x) xs)

`labelledExamples` generates three example test cases, one for each label:

    >>> labelledExamples prop_delete
    *** Found example of count x xs == 0
    0
    []
    []

    *** Found example of count x xs == 1
    0
    [0]
    []

    *** Found example of count x xs >= 2
    5
    [5,5]
    [5]

    +++ OK, passed 100 tests:
    78% count x xs == 0
    21% count x xs == 1
     1% count x xs >= 2

monomorphic :: Name -> ExpQ Source #

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 []`.

polyVerboseCheck :: Name -> ExpQ Source #

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 []`.

polyQuickCheck :: Name -> ExpQ Source #

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 []`.

isSuccess :: Result -> Bool Source #

Check if the test run result was a success

pattern Success :: Int -> Int -> !(Map [String] Int) -> !(Map String Int) -> !(Map String (Map String Int)) -> String -> Result Source #

A successful test run

pattern GaveUp :: Int -> Int -> !(Map [String] Int) -> !(Map String Int) -> !(Map String (Map String Int)) -> String -> Result Source #

Given up

pattern Failure :: Int -> Int -> Int -> Int -> Int -> QCGen -> Int -> String -> Maybe AnException -> String -> [String] -> [String] -> Set String -> Result Source #

A failed test run

pattern NoExpectedFailure :: Int -> Int -> !(Map [String] Int) -> !(Map String Int) -> !(Map String (Map String Int)) -> String -> Result Source #

A property that should have failed did not

numTests :: Result -> Int Source #

Number of tests performed

numDiscarded :: Result -> Int Source #

Number of tests skipped

labels :: Result -> Map [String] Int Source #

The number of test cases having each combination of labels (see `label`)

classes :: Result -> Map String Int Source #

The number of test cases having each class (see `classify`)

tables :: Result -> Map String (Map String Int) Source #

Data collected by `tabulate`

output :: Result -> String Source #

Printed output

numShrinks :: Result -> Int Source #

Number of successful shrinking steps performed

numShrinkTries :: Result -> Int Source #

Number of unsuccessful shrinking steps performed

numShrinkFinal :: Result -> Int Source #

Number of unsuccessful shrinking steps performed since last successful shrink

usedSeed :: Result -> QCGen Source #

What seed was used

usedSize :: Result -> Int Source #

What was the test size

reason :: Result -> String Source #

Why did the property fail

theException :: Result -> Maybe AnException Source #

The exception the property threw, if any

failingTestCase :: Result -> [String] Source #

The test case which provoked the failure

failingLabels :: Result -> [String] Source #

The test case's labels (see `label`)

failingClasses :: Result -> Set String Source #

The test case's classes (see `classify`)

total :: NFData a => a -> Property Source #

Checks that a value is total, i.e., doesn't crash when evaluated.

(=/=) :: (Eq a, Show a) => a -> a -> Property infix 4 Source #

Like `/=`, but prints a counterexample when it fails.

(===) :: (Eq a, Show a) => a -> a -> Property infix 4 Source #

Like `==`, but prints a counterexample when it fails.

disjoin :: Testable prop => [prop] -> Property Source #

Take the disjunction of several properties.

(.||.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property infixr 1 Source #

Disjunction: `p1` `.||.` `p2` passes unless `p1` and `p2` simultaneously fail.

conjoin :: Testable prop => [prop] -> Property Source #

Take the conjunction of several properties.

(.&&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property infixr 1 Source #

Conjunction: `p1` `.&&.` `p2` passes if both `p1` and `p2` pass.

(.&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property infixr 1 Source #

Nondeterministic choice: `p1` `.&.` `p2` picks randomly one of `p1` and `p2` to test. If you test the property 100 times it makes 100 random choices.

forAllShrinkBlind :: Testable prop => Gen a -> (a -> [a]) -> (a -> prop) -> Property Source #

Like `forAllShrink`, but without printing the generated value.

forAllShrinkShow :: Testable prop => Gen a -> (a -> [a]) -> (a -> String) -> (a -> prop) -> Property Source #

Like `forAllShrink`, but with an explicitly given show function.

forAllShrink :: (Show a, Testable prop) => Gen a -> (a -> [a]) -> (a -> prop) -> Property Source #

Like `forAll`, but tries to shrink the argument for failing test cases.

forAllBlind :: Testable prop => Gen a -> (a -> prop) -> Property Source #

Like `forAll`, but without printing the generated value.

forAllShow :: Testable prop => Gen a -> (a -> String) -> (a -> prop) -> Property Source #

Like `forAll`, but with an explicitly given show function.

forAll :: (Show a, Testable prop) => Gen a -> (a -> prop) -> Property Source #

Explicit universal quantification: uses an explicitly given test case generator.

within :: Testable prop => Int -> prop -> Property Source #

Considers a property failed if it does not complete within the given number of microseconds.

(==>) :: Testable prop => Bool -> prop -> Property infixr 0 Source #

Implication for properties: The resulting property holds if the first argument is `False` (in which case the test case is discarded), or if the given property holds. Note that using implication carelessly can severely skew test case distribution: consider using `cover` to make sure that your test data is still good quality.

coverTable :: Testable prop => String -> [(String, Double)] -> prop -> Property Source #

Checks that the values in a given `table` appear a certain proportion of the time. A call to `coverTable` `table` `[(x1, p1), ..., (xn, pn)]` asserts that of the values in `table`, `x1` should appear at least `p1` percent of the time, `x2` at least `p2` percent of the time, and so on.

Note: If the coverage check fails, QuickCheck prints out a warning, but the property does not fail. To make the property fail, use `checkCoverage`.

Continuing the example from the `tabular` combinator...

    data Command = LogIn | LogOut | SendMessage String deriving (Data, Show)
    prop_chatroom :: [Command] -> Property
    prop_chatroom cmds =
      wellFormed cmds LoggedOut ==>
      'tabulate' "Commands" (map (show . 'Data.Data.toConstr') cmds) $
        ...

...we can add a coverage requirement as follows, which checks that `LogIn`, `LogOut` and `SendMessage` each occur at least 25% of the time:

    prop_chatroom :: [Command] -> Property
    prop_chatroom cmds =
      wellFormed cmds LoggedOut ==>
      coverTable "Commands" [("LogIn", 25), ("LogOut", 25), ("SendMessage", 25)] $
      'tabulate' "Commands" (map (show . 'Data.Data.toConstr') cmds) $
        ... property goes here ...

    >>> quickCheck prop_chatroom
    +++ OK, passed 100 tests; 2909 discarded:
    56% 0
    17% 1
    10% 2
     6% 3
     5% 4
     3% 5
     3% 7

    Commands (111 in total):
    51.4% LogIn
    30.6% SendMessage
    18.0% LogOut

    Table 'Commands' had only 18.0% LogOut, but expected 25.0%

tabulate :: Testable prop => String -> [String] -> prop -> Property Source #

Collects information about test case distribution into a table. The arguments to `tabulate` are the table's name and a list of values associated with the current test case. After testing, QuickCheck prints the frequency of all collected values. The frequencies are expressed as a percentage of the total number of values collected.

You should prefer `tabulate` to `label` when each test case is associated with a varying number of values. Here is a (not terribly useful) example, where the test data is a list of integers and we record all values that occur in the list:

    prop_sorted_sort :: [Int] -> Property
    prop_sorted_sort xs =
      sorted xs ==>
      tabulate "List elements" (map show xs) $
      sort xs === xs

    >>> quickCheck prop_sorted_sort
    +++ OK, passed 100 tests; 1684 discarded.

    List elements (109 in total):
     3.7% 0
     3.7% 17
     3.7% 2
     3.7% 6
     2.8% -6
     2.8% -7

Here is a more useful example. We are testing a chatroom, where the user can log in, log out, or send a message:

    data Command = LogIn | LogOut | SendMessage String deriving (Data, Show)
    instance Arbitrary Command where ...

There are some restrictions on command sequences; for example, the user must log in before doing anything else. The function `valid :: [Command] -> Bool` checks that a command sequence is allowed. Our property then has the form:

    prop_chatroom :: [Command] -> Property
    prop_chatroom cmds =
      valid cmds ==>
        ...

The use of `==>` may skew test case distribution. We use `collect` to see the length of the command sequences, and `tabulate` to get the frequencies of the individual commands:

    prop_chatroom :: [Command] -> Property
    prop_chatroom cmds =
      wellFormed cmds LoggedOut ==>
      'collect' (length cmds) $
      'tabulate' "Commands" (map (show . 'Data.Data.toConstr') cmds) $
        ...

    >>> quickCheckWith stdArgs{maxDiscardRatio = 1000} prop_chatroom
    +++ OK, passed 100 tests; 2775 discarded:
    60% 0
    20% 1
    15% 2
     3% 3
     1% 4
     1% 5

    Commands (68 in total):
    62% LogIn
    22% SendMessage
    16% LogOut

cover Source #

Arguments

:: Testable prop |
=> Double | The required percentage (0-100) of test cases.
-> Bool | `True` if the test case belongs to the class.
-> String | Label for the test case class.
-> prop |
-> Property |

Checks that at least the given proportion of successful test cases belong to the given class. Discarded tests (i.e. ones with a false precondition) do not affect coverage.

Note: If the coverage check fails, QuickCheck prints out a warning, but the property does not fail. To make the property fail, use `checkCoverage`.

For example:

    prop_sorted_sort :: [Int] -> Property
    prop_sorted_sort xs =
      sorted xs ==>
      cover 50 (length xs > 1) "non-trivial" $
      sort xs === xs

    >>> quickCheck prop_sorted_sort
    +++ OK, passed 100 tests; 135 discarded (26% non-trivial).

    Only 26% non-trivial, but expected 50%

classify Source #

Arguments

:: Testable prop |
=> Bool | `True` if the test case should be labelled.
-> String | Label.
-> prop |
-> Property |

Reports how many test cases satisfy a given condition.

For example:

    prop_sorted_sort :: [Int] -> Property
    prop_sorted_sort xs =
      sorted xs ==>
      classify (length xs > 1) "non-trivial" $
      sort xs === xs

    >>> quickCheck prop_sorted_sort
    +++ OK, passed 100 tests (22% non-trivial).

collect :: (Show a, Testable prop) => a -> prop -> Property Source #

Attaches a label to a test case. This is used for reporting test case distribution.

    collect x = label (show x)

For example:

    prop_reverse_reverse :: [Int] -> Property
    prop_reverse_reverse xs =
      collect (length xs) $
        reverse (reverse xs) === xs

    >>> quickCheck prop_reverse_reverse
    +++ OK, passed 100 tests:
    7% 7
    6% 3
    5% 4
    4% 6
    ...

Each use of `collect` in your property results in a separate table of test case distribution in the output. If this is not what you want, use `tabulate`.

label :: Testable prop => String -> prop -> Property Source #

Attaches a label to a test case. This is used for reporting test case distribution.

For example:

    prop_reverse_reverse :: [Int] -> Property
    prop_reverse_reverse xs =
      label ("length of input is " ++ show (length xs)) $
        reverse (reverse xs) === xs

    >>> quickCheck prop_reverse_reverse
    +++ OK, passed 100 tests:
    7% length of input is 7
    6% length of input is 3
    5% length of input is 4
    4% length of input is 6
    ...

Each use of `label` in your property results in a separate table of test case distribution in the output. If this is not what you want, use `tabulate`.

stdConfidence :: Confidence Source #

The standard parameters used by `checkCoverage`: `certainty = 10^9`, `tolerance = 0.9`. See `Confidence` for the meaning of the parameters.

checkCoverageWith :: Testable prop => Confidence -> prop -> Property Source #

Check coverage requirements using a custom confidence level. See `stdConfidence`.

An example of making the statistical test less stringent in order to improve performance:

    quickCheck (checkCoverageWith stdConfidence{certainty = 10^6} prop_foo)

checkCoverage :: Testable prop => prop -> Property Source #

Check that all coverage requirements defined by `cover` and `coverTable` are met, using a statistically sound test, and fail if they are not met.

Ordinarily, a failed coverage check does not cause the property to fail. This is because the coverage requirement is not tested in a statistically sound way. If you use `cover` to express that a certain value must appear 20% of the time, QuickCheck will warn you if the value only appears in 19 out of 100 test cases - but since the coverage varies randomly, you may have just been unlucky, and there may not be any real problem with your test generation.

When you use `checkCoverage`, QuickCheck uses a statistical test to account for the role of luck in coverage failures. It will run as many tests as needed until it is sure about whether the coverage requirements are met. If a coverage requirement is not met, the property fails.

Example:

    quickCheck (checkCoverage prop_foo)

withMaxSuccess :: Testable prop => Int -> prop -> Property Source #

Configures how many times a property will be tested.

For example,

    quickCheck (withMaxSuccess 1000 p)

will test `p` up to 1000 times.

again :: Testable prop => prop -> Property Source #

Modifies a property so that it will be tested repeatedly. Opposite of `once`.

once :: Testable prop => prop -> Property Source #

Modifies a property so that it only will be tested once. Opposite of `again`.

expectFailure :: Testable prop => prop -> Property Source #

Indicates that a property is supposed to fail. QuickCheck will report an error if it does not fail.

verboseShrinking :: Testable prop => prop -> Property Source #

Prints out the generated testcase every time the property fails, including during shrinking. Only variables quantified over inside the `verboseShrinking` are printed.

whenFail' :: Testable prop => IO () -> prop -> Property Source #

Performs an `IO` action every time a property fails. Thus, if shrinking is done, this can be used to keep track of the failures along the way.

whenFail :: Testable prop => IO () -> prop -> Property Source #

Performs an `IO` action after the last failure of a property.

printTestCase :: Testable prop => String -> prop -> Property Source #

Adds the given string to the counterexample if the property fails.

counterexample :: Testable prop => String -> prop -> Property Source #

Adds the given string to the counterexample if the property fails.

noShrinking :: Testable prop => prop -> Property Source #

Disables shrinking for a property altogether. Only quantification inside the call to `noShrinking` is affected.

shrinking Source #

Arguments

:: Testable prop |
=> (a -> [a]) | `shrink`-like function.
-> a | The original argument
-> (a -> prop) |
-> Property |

Shrinks the argument to a property if it fails. Shrinking is done automatically for most types. This function is only needed when you want to override the default behavior.

mapSize :: Testable prop => (Int -> Int) -> prop -> Property Source #

Adjust the test case size for a property, by transforming it with the given function.

idempotentIOProperty :: Testable prop => IO prop -> Property Source #

Do I/O inside a property.

Warning: during shrinking, the I/O may not always be re-executed. Instead, the I/O may be executed once and then its result retained. If this is not acceptable, use `ioProperty` instead.

ioProperty :: Testable prop => IO prop -> Property Source #

Do I/O inside a property.

Warning: any random values generated inside of the argument to `ioProperty` will not currently be shrunk. For best results, generate all random values before calling `ioProperty`, or use `idempotentIOProperty` if that is safe.

Note: if your property does no quantification, it will only be tested once. To test it repeatedly, use `again`.

data Property Source #

The type of properties.

Instances

Testable Property |
Instance details Defined in Test.QuickCheck.Property Methods property :: Property -> Property Source #

class Testable prop where Source #

The class of properties, i.e., types which QuickCheck knows how to test. Typically a property will be a function returning `Bool` or `Property`.

If a property does no quantification, i.e. has no parameters and doesn't use `forAll`, it will only be tested once. This may not be what you want if your property is an `IO Bool`. You can change this behaviour using the `again` combinator.

Methods

property :: prop -> Property Source #

Convert the thing to a property.

Instances

Testable Bool |
Instance details Defined in Test.QuickCheck.Property Methods property :: Bool -> Property Source #
Testable () |
Instance details Defined in Test.QuickCheck.Property Methods property :: () -> Property Source #
Testable Prop |
Instance details Defined in Test.QuickCheck.Property Methods property :: Prop -> Property Source #
Testable Result |
Instance details Defined in Test.QuickCheck.Property Methods property :: Result -> Property Source #
Testable Property |
Instance details Defined in Test.QuickCheck.Property Methods property :: Property -> Property Source #
Testable Discard |
Instance details Defined in Test.QuickCheck.Property Methods property :: Discard -> Property Source #
Testable prop => Testable (Gen prop) |
Instance details Defined in Test.QuickCheck.Property Methods property :: Gen prop -> Property Source #
(Arbitrary a, Show a, Testable prop) => Testable (a -> prop) |
Instance details Defined in Test.QuickCheck.Property Methods property :: (a -> prop) -> Property Source #

data Discard Source #

If a property returns `Discard`, the current test case is discarded, the same as if a precondition was false.

An example is the definition of `==>`:

    (==>) :: Testable prop => Bool -> prop -> Property
    False ==> _ = property Discard
    True  ==> p = property p

Constructors

Discard |

Instances

Testable Discard |
Instance details Defined in Test.QuickCheck.Property Methods property :: Discard -> Property Source #

data Confidence Source #

The statistical parameters used by `checkCoverage`.

Constructors

Confidence |

Fields

- certainty :: Integer

  How certain `checkCoverage` must be before the property fails. If the coverage requirement is met, and the certainty parameter is `n`, then you should get a false positive at most one in `n` runs of QuickCheck. The default value is `10^9`.

  Lower values will speed up `checkCoverage` at the cost of false positives.

  If you are using `checkCoverage` as part of a test suite, you should be careful not to set `certainty` too low. If you want, say, a 1% chance of a false positive during a project's lifetime, then `certainty` should be set to at least `100 * m * n`, where `m` is the number of uses of `cover` in the test suite, and `n` is the number of times you expect the test suite to be run during the project's lifetime. The default value is chosen to be big enough for most projects.

- tolerance :: Double

  For statistical reasons, `checkCoverage` will not reject coverage levels that are only slightly below the required levels. If the required level is `p` then an actual level of `tolerance * p` will be accepted. The default value is `0.9`.

  Lower values will speed up `checkCoverage` at the cost of not detecting minor coverage violations.

Instances

Show Confidence |
Instance details Defined in Test.QuickCheck.State Methods showsPrec :: Int -> Confidence -> ShowS Source # show :: Confidence -> String Source # showList :: [Confidence] -> ShowS Source #

applyFun3 :: Fun (a, b, c) d -> a -> b -> c -> d Source #

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

applyFun2 :: Fun (a, b) c -> a -> b -> c Source #

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]

applyFun :: Fun a b -> a -> b Source #

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"

functionMap :: Function b => (a -> b) -> (b -> a) -> (a -> c) -> a :-> c Source #

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

functionShow :: (Show a, Read a) => (a -> c) -> a :-> c Source #

Provides a `Function` instance for types with `Show` and `Read`.

functionIntegral :: Integral a => (a -> b) -> a :-> b Source #

Provides a `Function` instance for types with `Integral`.

functionRealFrac :: RealFrac a => (a -> b) -> a :-> b Source #

Provides a `Function` instance for types with `RealFrac`.

functionBoundedEnum :: (Eq a, Bounded a, Enum a) => (a -> b) -> a :-> b Source #

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

pattern Fn :: forall a b. (a -> b) -> Fun a b Source #

A modifier for testing functions.

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

pattern Fn2 :: forall a b c. (a -> b -> c) -> Fun (a, b) c Source #

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]

pattern Fn3 :: forall a b c d. (a -> b -> c -> d) -> Fun (a, b, c) d Source #

A modifier for testing ternary functions.

class Function a where Source #

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`.

Minimal complete definition

Nothing

Methods

function :: (a -> b) -> a :-> b Source #

Instances

Function Bool |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Bool -> b) -> Bool :-> b Source #
Function Char |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Char -> b) -> Char :-> b Source #
Function Double |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Double -> b) -> Double :-> b Source #
Function Float |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Float -> b) -> Float :-> b Source #
Function Int |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int -> b) -> Int :-> b Source #
Function Int8 |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int8 -> b) -> Int8 :-> b Source #
Function Int16 |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int16 -> b) -> Int16 :-> b Source #
Function Int32 |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int32 -> b) -> Int32 :-> b Source #
Function Int64 |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int64 -> b) -> Int64 :-> b Source #
Function Integer |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Integer -> b) -> Integer :-> b Source #
Function Ordering |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Ordering -> b) -> Ordering :-> b Source #
Function Word |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word -> b) -> Word :-> b Source #
Function Word8 |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word8 -> b) -> Word8 :-> b Source #
Function Word16 |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word16 -> b) -> Word16 :-> b Source #
Function Word32 |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word32 -> b) -> Word32 :-> b Source #
Function Word64 |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word64 -> b) -> Word64 :-> b Source #
Function () |
Instance details Defined in Test.QuickCheck.Function Methods function :: (() -> b) -> () :-> b Source #
Function A |
Instance details Defined in Test.QuickCheck.Function Methods function :: (A -> b) -> A :-> b Source #
Function B |
Instance details Defined in Test.QuickCheck.Function Methods function :: (B -> b) -> B :-> b Source #
Function C |
Instance details Defined in Test.QuickCheck.Function Methods function :: (C -> b) -> C :-> b Source #
Function OrdA |
Instance details Defined in Test.QuickCheck.Function Methods function :: (OrdA -> b) -> OrdA :-> b Source #
Function OrdB |
Instance details Defined in Test.QuickCheck.Function Methods function :: (OrdB -> b) -> OrdB :-> b Source #
Function OrdC |
Instance details Defined in Test.QuickCheck.Function Methods function :: (OrdC -> b) -> OrdC :-> b Source #
Function All |
Instance details Defined in Test.QuickCheck.Function Methods function :: (All -> b) -> All :-> b Source #
Function Any |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Any -> b) -> Any :-> b Source #
Function IntSet |
Instance details Defined in Test.QuickCheck.Function Methods function :: (IntSet -> b) -> IntSet :-> b Source #
Function a => Function [a] |
Instance details Defined in Test.QuickCheck.Function Methods function :: ([a] -> b) -> [a] :-> b Source #
Function a => Function (Maybe a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Maybe a -> b) -> Maybe a :-> b Source #
(Integral a, Function a) => Function (Ratio a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Ratio a -> b) -> Ratio a :-> b Source #
(RealFloat a, Function a) => Function (Complex a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Complex a -> b) -> Complex a :-> b Source #
HasResolution a => Function (Fixed a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Fixed a -> b) -> Fixed a :-> b Source #
Function a => Function (Identity a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Identity a -> b) -> Identity a :-> b Source #
Function a => Function (First a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (First a -> b) -> First a :-> b Source #
Function a => Function (Last a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Last a -> b) -> Last a :-> b Source #
Function a => Function (Dual a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Dual a -> b) -> Dual a :-> b Source #
Function a => Function (Sum a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Sum a -> b) -> Sum a :-> b Source #
Function a => Function (Product a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Product a -> b) -> Product a :-> b Source #
Function a => Function (IntMap a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (IntMap a -> b) -> IntMap a :-> b Source #
Function a => Function (Seq a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Seq a -> b) -> Seq a :-> b Source #
(Ord a, Function a) => Function (Set a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Set a -> b) -> Set a :-> b Source #
(Function a, Function b) => Function (Either a b) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Either a b -> b0) -> Either a b :-> b0 Source #
(Function a, Function b) => Function (a, b) |
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b) -> b0) -> (a, b) :-> b0 Source #
(Ord a, Function a, Function b) => Function (Map a b) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Map a b -> b0) -> Map a b :-> b0 Source #
(Function a, Function b, Function c) => Function (a, b, c) |
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c) -> b0) -> (a, b, c) :-> b0 Source #
Function a => Function (Const a b) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Const a b -> b0) -> Const a b :-> b0 Source #
Function (f a) => Function (Alt f a) |
Instance details Defined in Test.QuickCheck.Function Methods function :: (Alt f a -> b) -> Alt f a :-> b Source #
(Function a, Function b, Function c, Function d) => Function (a, b, c, d) |
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c, d) -> b0) -> (a, b, c, d) :-> b0 Source #
(Function a, Function b, Function c, Function d, Function e) => Function (a, b, c, d, e) |
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c, d, e) -> b0) -> (a, b, c, d, e) :-> b0 Source #
(Function a, Function b, Function c, Function d, Function e, Function f) => Function (a, b, c, d, e, f) |
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c, d, e, f) -> b0) -> (a, b, c, d, e, f) :-> b0 Source #
(Function a, Function b, Function c, Function d, Function e, Function f, Function g) => Function (a, b, c, d, e, f, g) |
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c, d, e, f, g) -> b0) -> (a, b, c, d, e, f, g) :-> b0 Source #

data Fun a b Source #

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.

Constructors

Fun (a :-> b, b, Shrunk) (a -> b) |

Instances

Functor (Fun a) |
Instance details Defined in Test.QuickCheck.Function Methods fmap :: (a0 -> b) -> Fun a a0 -> Fun a b Source # (<$) :: a0 -> Fun a b -> Fun a a0 Source #
(Show a, Show b) => Show (Fun a b) |
Instance details Defined in Test.QuickCheck.Function Methods showsPrec :: Int -> Fun a b -> ShowS Source # show :: Fun a b -> String Source # showList :: [Fun a b] -> ShowS Source #
(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (Fun a b) |
Instance details Defined in Test.QuickCheck.Function Methods arbitrary :: Gen (Fun a b) Source # shrink :: Fun a b -> [Fun a b] Source #

newtype Blind a Source #

`Blind x`: as x, but x does not have to be in the `Show` class.

Constructors

Blind |

Fields

- getBlind :: a

Instances

Functor Blind |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Blind a -> Blind b Source # (<$) :: a -> Blind b -> Blind a Source #
Enum a => Enum (Blind a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Blind a -> Blind a Source #

pred :: Blind a -> Blind a Source #

toEnum :: Int -> Blind a Source #

fromEnum :: Blind a -> Int Source #

enumFrom :: Blind a -> [Blind a] Source #

enumFromThen :: Blind a -> Blind a -> [Blind a] Source #

enumFromTo :: Blind a -> Blind a -> [Blind a] Source #

enumFromThenTo :: Blind a -> Blind a -> Blind a -> [Blind a] Source #

Eq a => Eq (Blind a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Blind a -> Blind a -> Bool Source # (/=) :: Blind a -> Blind a -> Bool Source #
Integral a => Integral (Blind a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Blind a -> Blind a -> Blind a Source #

rem :: Blind a -> Blind a -> Blind a Source #

div :: Blind a -> Blind a -> Blind a Source #

mod :: Blind a -> Blind a -> Blind a Source #

quotRem :: Blind a -> Blind a -> (Blind a, Blind a) Source #

divMod :: Blind a -> Blind a -> (Blind a, Blind a) Source #

toInteger :: Blind a -> Integer Source #

Num a => Num (Blind a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Blind a -> Blind a -> Blind a Source # (-) :: Blind a -> Blind a -> Blind a Source # (*) :: Blind a -> Blind a -> Blind a Source # negate :: Blind a -> Blind a Source # abs :: Blind a -> Blind a Source # signum :: Blind a -> Blind a Source # fromInteger :: Integer -> Blind a Source #
Ord a => Ord (Blind a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Blind a -> Blind a -> Ordering Source # (<) :: Blind a -> Blind a -> Bool Source # (<=) :: Blind a -> Blind a -> Bool Source # (>) :: Blind a -> Blind a -> Bool Source # (>=) :: Blind a -> Blind a -> Bool Source # max :: Blind a -> Blind a -> Blind a Source # min :: Blind a -> Blind a -> Blind a Source #
Real a => Real (Blind a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Blind a -> Rational Source #
Show (Blind a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Blind a -> ShowS Source # show :: Blind a -> String Source # showList :: [Blind a] -> ShowS Source #
Arbitrary a => Arbitrary (Blind a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Blind a) Source # shrink :: Blind a -> [Blind a] Source #

newtype Fixed a Source #

`Fixed x`: as x, but will not be shrunk.

Constructors

Fixed |

Fields

- getFixed :: a

Instances

Functor Fixed |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Fixed a -> Fixed b Source # (<$) :: a -> Fixed b -> Fixed a Source #
Enum a => Enum (Fixed a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Fixed a -> Fixed a Source #

pred :: Fixed a -> Fixed a Source #

toEnum :: Int -> Fixed a Source #

fromEnum :: Fixed a -> Int Source #

enumFrom :: Fixed a -> [Fixed a] Source #

enumFromThen :: Fixed a -> Fixed a -> [Fixed a] Source #

enumFromTo :: Fixed a -> Fixed a -> [Fixed a] Source #

enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] Source #

Eq a => Eq (Fixed a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Fixed a -> Fixed a -> Bool Source # (/=) :: Fixed a -> Fixed a -> Bool Source #
Integral a => Integral (Fixed a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Fixed a -> Fixed a -> Fixed a Source #

rem :: Fixed a -> Fixed a -> Fixed a Source #

div :: Fixed a -> Fixed a -> Fixed a Source #

mod :: Fixed a -> Fixed a -> Fixed a Source #

quotRem :: Fixed a -> Fixed a -> (Fixed a, Fixed a) Source #

divMod :: Fixed a -> Fixed a -> (Fixed a, Fixed a) Source #

toInteger :: Fixed a -> Integer Source #

Num a => Num (Fixed a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Fixed a -> Fixed a -> Fixed a Source # (-) :: Fixed a -> Fixed a -> Fixed a Source # (*) :: Fixed a -> Fixed a -> Fixed a Source # negate :: Fixed a -> Fixed a Source # abs :: Fixed a -> Fixed a Source # signum :: Fixed a -> Fixed a Source # fromInteger :: Integer -> Fixed a Source #
Ord a => Ord (Fixed a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Fixed a -> Fixed a -> Ordering Source # (<) :: Fixed a -> Fixed a -> Bool Source # (<=) :: Fixed a -> Fixed a -> Bool Source # (>) :: Fixed a -> Fixed a -> Bool Source # (>=) :: Fixed a -> Fixed a -> Bool Source # max :: Fixed a -> Fixed a -> Fixed a Source # min :: Fixed a -> Fixed a -> Fixed a Source #
Read a => Read (Fixed a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Fixed a) Source # readList :: ReadS [Fixed a] Source # readPrec :: ReadPrec (Fixed a) Source # readListPrec :: ReadPrec [Fixed a] Source #
Real a => Real (Fixed a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Fixed a -> Rational Source #
Show a => Show (Fixed a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Fixed a -> ShowS Source # show :: Fixed a -> String Source # showList :: [Fixed a] -> ShowS Source #
Arbitrary a => Arbitrary (Fixed a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Fixed a) Source # shrink :: Fixed a -> [Fixed a] Source #

newtype OrderedList a Source #

`Ordered xs`: guarantees that xs is ordered.

Constructors

Ordered |

Fields

- getOrdered :: [a]

Instances

Functor OrderedList |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> OrderedList a -> OrderedList b Source # (<$) :: a -> OrderedList b -> OrderedList a Source #
Eq a => Eq (OrderedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: OrderedList a -> OrderedList a -> Bool Source # (/=) :: OrderedList a -> OrderedList a -> Bool Source #
Ord a => Ord (OrderedList a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: OrderedList a -> OrderedList a -> Ordering Source #

(<) :: OrderedList a -> OrderedList a -> Bool Source #

(<=) :: OrderedList a -> OrderedList a -> Bool Source #

(>) :: OrderedList a -> OrderedList a -> Bool Source #

(>=) :: OrderedList a -> OrderedList a -> Bool Source #

max :: OrderedList a -> OrderedList a -> OrderedList a Source #

min :: OrderedList a -> OrderedList a -> OrderedList a Source #

Read a => Read (OrderedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (OrderedList a) Source # readList :: ReadS [OrderedList a] Source # readPrec :: ReadPrec (OrderedList a) Source # readListPrec :: ReadPrec [OrderedList a] Source #
Show a => Show (OrderedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> OrderedList a -> ShowS Source # show :: OrderedList a -> String Source # showList :: [OrderedList a] -> ShowS Source #
(Ord a, Arbitrary a) => Arbitrary (OrderedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (OrderedList a) Source # shrink :: OrderedList a -> [OrderedList a] Source #

newtype NonEmptyList a Source #

`NonEmpty xs`: guarantees that xs is non-empty.

Constructors

NonEmpty |

Fields

- getNonEmpty :: [a]

Instances

Functor NonEmptyList |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonEmptyList a -> NonEmptyList b Source # (<$) :: a -> NonEmptyList b -> NonEmptyList a Source #
Eq a => Eq (NonEmptyList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: NonEmptyList a -> NonEmptyList a -> Bool Source # (/=) :: NonEmptyList a -> NonEmptyList a -> Bool Source #
Ord a => Ord (NonEmptyList a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: NonEmptyList a -> NonEmptyList a -> Ordering Source #

(<) :: NonEmptyList a -> NonEmptyList a -> Bool Source #

(<=) :: NonEmptyList a -> NonEmptyList a -> Bool Source #

(>) :: NonEmptyList a -> NonEmptyList a -> Bool Source #

(>=) :: NonEmptyList a -> NonEmptyList a -> Bool Source #

max :: NonEmptyList a -> NonEmptyList a -> NonEmptyList a Source #

min :: NonEmptyList a -> NonEmptyList a -> NonEmptyList a Source #

Read a => Read (NonEmptyList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (NonEmptyList a) Source # readList :: ReadS [NonEmptyList a] Source # readPrec :: ReadPrec (NonEmptyList a) Source # readListPrec :: ReadPrec [NonEmptyList a] Source #
Show a => Show (NonEmptyList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonEmptyList a -> ShowS Source # show :: NonEmptyList a -> String Source # showList :: [NonEmptyList a] -> ShowS Source #
Arbitrary a => Arbitrary (NonEmptyList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonEmptyList a) Source # shrink :: NonEmptyList a -> [NonEmptyList a] Source #

data InfiniteList a Source #

`InfiniteList xs _`: guarantees that xs is an infinite list. When a counterexample is found, only prints the prefix of xs that was used by the program.

Here is a contrived example property:

    prop_take_10 :: InfiniteList Char -> Bool
    prop_take_10 (InfiniteList xs _) =
      or [ x == 'a' | x <- take 10 xs ]

In the following counterexample, the list must start with `"bbbbbbbbbb"` but the remaining (infinite) part can contain anything:

    >>> quickCheck prop_take_10
    *** Failed! Falsifiable (after 1 test and 14 shrinks):
    "bbbbbbbbbb" ++ ...

Constructors

InfiniteList |

Fields

- getInfiniteList :: [a]
- infiniteListInternalData :: InfiniteListInternalData a

Instances

Show a => Show (InfiniteList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> InfiniteList a -> ShowS Source # show :: InfiniteList a -> String Source # showList :: [InfiniteList a] -> ShowS Source #
Arbitrary a => Arbitrary (InfiniteList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (InfiniteList a) Source # shrink :: InfiniteList a -> [InfiniteList a] Source #

newtype SortedList a Source #

`Sorted xs`: guarantees that xs is sorted.

Constructors

Sorted |

Fields

- getSorted :: [a]

Instances

Functor SortedList |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> SortedList a -> SortedList b Source # (<$) :: a -> SortedList b -> SortedList a Source #
Eq a => Eq (SortedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: SortedList a -> SortedList a -> Bool Source # (/=) :: SortedList a -> SortedList a -> Bool Source #
Ord a => Ord (SortedList a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: SortedList a -> SortedList a -> Ordering Source #

(<) :: SortedList a -> SortedList a -> Bool Source #

(<=) :: SortedList a -> SortedList a -> Bool Source #

(>) :: SortedList a -> SortedList a -> Bool Source #

(>=) :: SortedList a -> SortedList a -> Bool Source #

max :: SortedList a -> SortedList a -> SortedList a Source #

min :: SortedList a -> SortedList a -> SortedList a Source #

Read a => Read (SortedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (SortedList a) Source # readList :: ReadS [SortedList a] Source # readPrec :: ReadPrec (SortedList a) Source # readListPrec :: ReadPrec [SortedList a] Source #
Show a => Show (SortedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> SortedList a -> ShowS Source # show :: SortedList a -> String Source # showList :: [SortedList a] -> ShowS Source #
(Arbitrary a, Ord a) => Arbitrary (SortedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (SortedList a) Source # shrink :: SortedList a -> [SortedList a] Source #

newtype Positive a Source #

`Positive x`: guarantees that `x > 0`.

Constructors

Positive |

Fields

- getPositive :: a

Instances

Functor Positive |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Positive a -> Positive b Source # (<$) :: a -> Positive b -> Positive a Source #
Enum a => Enum (Positive a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Positive a -> Positive a Source #

pred :: Positive a -> Positive a Source #

toEnum :: Int -> Positive a Source #

fromEnum :: Positive a -> Int Source #

enumFrom :: Positive a -> [Positive a] Source #

enumFromThen :: Positive a -> Positive a -> [Positive a] Source #

enumFromTo :: Positive a -> Positive a -> [Positive a] Source #

enumFromThenTo :: Positive a -> Positive a -> Positive a -> [Positive a] Source #

Eq a => Eq (Positive a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Positive a -> Positive a -> Bool Source # (/=) :: Positive a -> Positive a -> Bool Source #
Ord a => Ord (Positive a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: Positive a -> Positive a -> Ordering Source #

(<) :: Positive a -> Positive a -> Bool Source #

(<=) :: Positive a -> Positive a -> Bool Source #

(>) :: Positive a -> Positive a -> Bool Source #

(>=) :: Positive a -> Positive a -> Bool Source #

max :: Positive a -> Positive a -> Positive a Source #

min :: Positive a -> Positive a -> Positive a Source #

Read a => Read (Positive a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Positive a) Source # readList :: ReadS [Positive a] Source # readPrec :: ReadPrec (Positive a) Source # readListPrec :: ReadPrec [Positive a] Source #
Show a => Show (Positive a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Positive a -> ShowS Source # show :: Positive a -> String Source # showList :: [Positive a] -> ShowS Source #
(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Positive a) Source # shrink :: Positive a -> [Positive a] Source #

newtype NonZero a Source #

`NonZero x`: guarantees that `x /= 0`.

Constructors

NonZero |

Fields

- getNonZero :: a

Instances

Functor NonZero |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonZero a -> NonZero b Source # (<$) :: a -> NonZero b -> NonZero a Source #
Enum a => Enum (NonZero a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

succ :: NonZero a -> NonZero a Source #

pred :: NonZero a -> NonZero a Source #

toEnum :: Int -> NonZero a Source #

fromEnum :: NonZero a -> Int Source #

enumFrom :: NonZero a -> [NonZero a] Source #

enumFromThen :: NonZero a -> NonZero a -> [NonZero a] Source #

enumFromTo :: NonZero a -> NonZero a -> [NonZero a] Source #

enumFromThenTo :: NonZero a -> NonZero a -> NonZero a -> [NonZero a] Source #

Eq a => Eq (NonZero a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: NonZero a -> NonZero a -> Bool Source # (/=) :: NonZero a -> NonZero a -> Bool Source #
Ord a => Ord (NonZero a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: NonZero a -> NonZero a -> Ordering Source #

(<) :: NonZero a -> NonZero a -> Bool Source #

(<=) :: NonZero a -> NonZero a -> Bool Source #

(>) :: NonZero a -> NonZero a -> Bool Source #

(>=) :: NonZero a -> NonZero a -> Bool Source #

max :: NonZero a -> NonZero a -> NonZero a Source #

min :: NonZero a -> NonZero a -> NonZero a Source #

Read a => Read (NonZero a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (NonZero a) Source # readList :: ReadS [NonZero a] Source # readPrec :: ReadPrec (NonZero a) Source # readListPrec :: ReadPrec [NonZero a] Source #
Show a => Show (NonZero a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonZero a -> ShowS Source # show :: NonZero a -> String Source # showList :: [NonZero a] -> ShowS Source #
(Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonZero a) Source # shrink :: NonZero a -> [NonZero a] Source #

newtype NonNegative a Source #

`NonNegative x`: guarantees that `x >= 0`.

Constructors

NonNegative |

Fields

- getNonNegative :: a

Instances

Functor NonNegative |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonNegative a -> NonNegative b Source # (<$) :: a -> NonNegative b -> NonNegative a Source #
Enum a => Enum (NonNegative a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

succ :: NonNegative a -> NonNegative a Source #

pred :: NonNegative a -> NonNegative a Source #

toEnum :: Int -> NonNegative a Source #

fromEnum :: NonNegative a -> Int Source #

enumFrom :: NonNegative a -> [NonNegative a] Source #

enumFromThen :: NonNegative a -> NonNegative a -> [NonNegative a] Source #

enumFromTo :: NonNegative a -> NonNegative a -> [NonNegative a] Source #

enumFromThenTo :: NonNegative a -> NonNegative a -> NonNegative a -> [NonNegative a] Source #

Eq a => Eq (NonNegative a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: NonNegative a -> NonNegative a -> Bool Source # (/=) :: NonNegative a -> NonNegative a -> Bool Source #
Ord a => Ord (NonNegative a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: NonNegative a -> NonNegative a -> Ordering Source #

(<) :: NonNegative a -> NonNegative a -> Bool Source #

(<=) :: NonNegative a -> NonNegative a -> Bool Source #

(>) :: NonNegative a -> NonNegative a -> Bool Source #

(>=) :: NonNegative a -> NonNegative a -> Bool Source #

max :: NonNegative a -> NonNegative a -> NonNegative a Source #

min :: NonNegative a -> NonNegative a -> NonNegative a Source #

Read a => Read (NonNegative a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (NonNegative a) Source # readList :: ReadS [NonNegative a] Source # readPrec :: ReadPrec (NonNegative a) Source # readListPrec :: ReadPrec [NonNegative a] Source #
Show a => Show (NonNegative a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonNegative a -> ShowS Source # show :: NonNegative a -> String Source # showList :: [NonNegative a] -> ShowS Source #
(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonNegative a) Source # shrink :: NonNegative a -> [NonNegative a] Source #

newtype Large a Source #

`Large x`: by default, QuickCheck generates `Int`s drawn from a small range. `Large Int` gives you values drawn from the entire range instead.

Constructors

Large |

Fields

- getLarge :: a

Instances

Functor Large |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Large a -> Large b Source # (<$) :: a -> Large b -> Large a Source #
Enum a => Enum (Large a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Large a -> Large a Source #

pred :: Large a -> Large a Source #

toEnum :: Int -> Large a Source #

fromEnum :: Large a -> Int Source #

enumFrom :: Large a -> [Large a] Source #

enumFromThen :: Large a -> Large a -> [Large a] Source #

enumFromTo :: Large a -> Large a -> [Large a] Source #

enumFromThenTo :: Large a -> Large a -> Large a -> [Large a] Source #

Eq a => Eq (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Large a -> Large a -> Bool Source # (/=) :: Large a -> Large a -> Bool Source #
Integral a => Integral (Large a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Large a -> Large a -> Large a Source #

rem :: Large a -> Large a -> Large a Source #

div :: Large a -> Large a -> Large a Source #

mod :: Large a -> Large a -> Large a Source #

quotRem :: Large a -> Large a -> (Large a, Large a) Source #

divMod :: Large a -> Large a -> (Large a, Large a) Source #

toInteger :: Large a -> Integer Source #

Num a => Num (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Large a -> Large a -> Large a Source # (-) :: Large a -> Large a -> Large a Source # (*) :: Large a -> Large a -> Large a Source # negate :: Large a -> Large a Source # abs :: Large a -> Large a Source # signum :: Large a -> Large a Source # fromInteger :: Integer -> Large a Source #
Ord a => Ord (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Large a -> Large a -> Ordering Source # (<) :: Large a -> Large a -> Bool Source # (<=) :: Large a -> Large a -> Bool Source # (>) :: Large a -> Large a -> Bool Source # (>=) :: Large a -> Large a -> Bool Source # max :: Large a -> Large a -> Large a Source # min :: Large a -> Large a -> Large a Source #
Read a => Read (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Large a) Source # readList :: ReadS [Large a] Source # readPrec :: ReadPrec (Large a) Source # readListPrec :: ReadPrec [Large a] Source #
Real a => Real (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Large a -> Rational Source #
Show a => Show (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Large a -> ShowS Source # show :: Large a -> String Source # showList :: [Large a] -> ShowS Source #
Ix a => Ix (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods range :: (Large a, Large a) -> [Large a] Source # index :: (Large a, Large a) -> Large a -> Int Source # unsafeIndex :: (Large a, Large a) -> Large a -> Int inRange :: (Large a, Large a) -> Large a -> Bool Source # rangeSize :: (Large a, Large a) -> Int Source # unsafeRangeSize :: (Large a, Large a) -> Int
(Integral a, Bounded a) => Arbitrary (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Large a) Source # shrink :: Large a -> [Large a] Source #

newtype Small a Source #

`Small x`: generates values of `x` drawn from a small range. The opposite of `Large`.

Constructors

Small |

Fields

- getSmall :: a

Instances

Functor Small |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Small a -> Small b Source # (<$) :: a -> Small b -> Small a Source #
Enum a => Enum (Small a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Small a -> Small a Source #

pred :: Small a -> Small a Source #

toEnum :: Int -> Small a Source #

fromEnum :: Small a -> Int Source #

enumFrom :: Small a -> [Small a] Source #

enumFromThen :: Small a -> Small a -> [Small a] Source #

enumFromTo :: Small a -> Small a -> [Small a] Source #

enumFromThenTo :: Small a -> Small a -> Small a -> [Small a] Source #

Eq a => Eq (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Small a -> Small a -> Bool Source # (/=) :: Small a -> Small a -> Bool Source #
Integral a => Integral (Small a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Small a -> Small a -> Small a Source #

rem :: Small a -> Small a -> Small a Source #

div :: Small a -> Small a -> Small a Source #

mod :: Small a -> Small a -> Small a Source #

quotRem :: Small a -> Small a -> (Small a, Small a) Source #

divMod :: Small a -> Small a -> (Small a, Small a) Source #

toInteger :: Small a -> Integer Source #

Num a => Num (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Small a -> Small a -> Small a Source # (-) :: Small a -> Small a -> Small a Source # (*) :: Small a -> Small a -> Small a Source # negate :: Small a -> Small a Source # abs :: Small a -> Small a Source # signum :: Small a -> Small a Source # fromInteger :: Integer -> Small a Source #
Ord a => Ord (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Small a -> Small a -> Ordering Source # (<) :: Small a -> Small a -> Bool Source # (<=) :: Small a -> Small a -> Bool Source # (>) :: Small a -> Small a -> Bool Source # (>=) :: Small a -> Small a -> Bool Source # max :: Small a -> Small a -> Small a Source # min :: Small a -> Small a -> Small a Source #
Read a => Read (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Small a) Source # readList :: ReadS [Small a] Source # readPrec :: ReadPrec (Small a) Source # readListPrec :: ReadPrec [Small a] Source #
Real a => Real (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Small a -> Rational Source #
Show a => Show (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Small a -> ShowS Source # show :: Small a -> String Source # showList :: [Small a] -> ShowS Source #
Ix a => Ix (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods range :: (Small a, Small a) -> [Small a] Source # index :: (Small a, Small a) -> Small a -> Int Source # unsafeIndex :: (Small a, Small a) -> Small a -> Int inRange :: (Small a, Small a) -> Small a -> Bool Source # rangeSize :: (Small a, Small a) -> Int Source # unsafeRangeSize :: (Small a, Small a) -> Int
Integral a => Arbitrary (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Small a) Source # shrink :: Small a -> [Small a] Source #

newtype Shrink2 a Source #

`Shrink2 x`: allows 2 shrinking steps at the same time when shrinking x

Constructors

Shrink2 |

Fields

- getShrink2 :: a

Instances

Functor Shrink2 |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Shrink2 a -> Shrink2 b Source # (<$) :: a -> Shrink2 b -> Shrink2 a Source #
Enum a => Enum (Shrink2 a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

succ :: Shrink2 a -> Shrink2 a Source #

pred :: Shrink2 a -> Shrink2 a Source #

toEnum :: Int -> Shrink2 a Source #

fromEnum :: Shrink2 a -> Int Source #

enumFrom :: Shrink2 a -> [Shrink2 a] Source #

enumFromThen :: Shrink2 a -> Shrink2 a -> [Shrink2 a] Source #

enumFromTo :: Shrink2 a -> Shrink2 a -> [Shrink2 a] Source #

enumFromThenTo :: Shrink2 a -> Shrink2 a -> Shrink2 a -> [Shrink2 a] Source #

Eq a => Eq (Shrink2 a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Shrink2 a -> Shrink2 a -> Bool Source # (/=) :: Shrink2 a -> Shrink2 a -> Bool Source #
Integral a => Integral (Shrink2 a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

quot :: Shrink2 a -> Shrink2 a -> Shrink2 a Source #

rem :: Shrink2 a -> Shrink2 a -> Shrink2 a Source #

div :: Shrink2 a -> Shrink2 a -> Shrink2 a Source #

mod :: Shrink2 a -> Shrink2 a -> Shrink2 a Source #

quotRem :: Shrink2 a -> Shrink2 a -> (Shrink2 a, Shrink2 a) Source #

divMod :: Shrink2 a -> Shrink2 a -> (Shrink2 a, Shrink2 a) Source #

toInteger :: Shrink2 a -> Integer Source #

Num a => Num (Shrink2 a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Shrink2 a -> Shrink2 a -> Shrink2 a Source # (-) :: Shrink2 a -> Shrink2 a -> Shrink2 a Source # (*) :: Shrink2 a -> Shrink2 a -> Shrink2 a Source # negate :: Shrink2 a -> Shrink2 a Source # abs :: Shrink2 a -> Shrink2 a Source # signum :: Shrink2 a -> Shrink2 a Source # fromInteger :: Integer -> Shrink2 a Source #
Ord a => Ord (Shrink2 a) |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: Shrink2 a -> Shrink2 a -> Ordering Source #

(<) :: Shrink2 a -> Shrink2 a -> Bool Source #

(<=) :: Shrink2 a -> Shrink2 a -> Bool Source #

(>) :: Shrink2 a -> Shrink2 a -> Bool Source #

(>=) :: Shrink2 a -> Shrink2 a -> Bool Source #

max :: Shrink2 a -> Shrink2 a -> Shrink2 a Source #

min :: Shrink2 a -> Shrink2 a -> Shrink2 a Source #

Read a => Read (Shrink2 a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Shrink2 a) Source # readList :: ReadS [Shrink2 a] Source # readPrec :: ReadPrec (Shrink2 a) Source # readListPrec :: ReadPrec [Shrink2 a] Source #
Real a => Real (Shrink2 a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Shrink2 a -> Rational Source #
Show a => Show (Shrink2 a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Shrink2 a -> ShowS Source # show :: Shrink2 a -> String Source # showList :: [Shrink2 a] -> ShowS Source #
Arbitrary a => Arbitrary (Shrink2 a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Shrink2 a) Source # shrink :: Shrink2 a -> [Shrink2 a] Source #

data Smart a Source #

`Smart _ x`: tries a different order when shrinking.

Constructors

Smart Int a |

Instances

Functor Smart |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Smart a -> Smart b Source # (<$) :: a -> Smart b -> Smart a Source #
Show a => Show (Smart a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Smart a -> ShowS Source # show :: Smart a -> String Source # showList :: [Smart a] -> ShowS Source #
Arbitrary a => Arbitrary (Smart a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Smart a) Source # shrink :: Smart a -> [Smart a] Source #

data Shrinking s a Source #

`Shrinking _ x`: allows for maintaining a state during shrinking.

Constructors

Shrinking s a |

Instances

Functor (Shrinking s) |
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Shrinking s a -> Shrinking s b Source # (<$) :: a -> Shrinking s b -> Shrinking s a Source #
Show a => Show (Shrinking s a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Shrinking s a -> ShowS Source # show :: Shrinking s a -> String Source # showList :: [Shrinking s a] -> ShowS Source #
(Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Shrinking s a) Source # shrink :: Shrinking s a -> [Shrinking s a] Source #

class ShrinkState s a where Source #

Methods

shrinkInit :: a -> s Source #

shrinkState :: a -> s -> [(a, s)] Source #

newtype ASCIIString Source #

`ASCIIString`: generates an ASCII string.

Constructors

ASCIIString |

Fields

- getASCIIString :: String

Instances

Eq ASCIIString |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: ASCIIString -> ASCIIString -> Bool Source # (/=) :: ASCIIString -> ASCIIString -> Bool Source #
Ord ASCIIString |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: ASCIIString -> ASCIIString -> Ordering Source #

(<) :: ASCIIString -> ASCIIString -> Bool Source #

(<=) :: ASCIIString -> ASCIIString -> Bool Source #

(>) :: ASCIIString -> ASCIIString -> Bool Source #

(>=) :: ASCIIString -> ASCIIString -> Bool Source #

max :: ASCIIString -> ASCIIString -> ASCIIString Source #

min :: ASCIIString -> ASCIIString -> ASCIIString Source #

Read ASCIIString |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS ASCIIString Source # readList :: ReadS [ASCIIString] Source # readPrec :: ReadPrec ASCIIString Source # readListPrec :: ReadPrec [ASCIIString] Source #
Show ASCIIString |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> ASCIIString -> ShowS Source # show :: ASCIIString -> String Source # showList :: [ASCIIString] -> ShowS Source #
Arbitrary ASCIIString |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen ASCIIString Source # shrink :: ASCIIString -> [ASCIIString] Source #

newtype UnicodeString Source #

`UnicodeString`: generates a unicode String. The string will not contain surrogate pairs.

Constructors

UnicodeString |

Fields

- getUnicodeString :: String

Instances

Eq UnicodeString |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: UnicodeString -> UnicodeString -> Bool Source # (/=) :: UnicodeString -> UnicodeString -> Bool Source #
Ord UnicodeString |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: UnicodeString -> UnicodeString -> Ordering Source #

(<) :: UnicodeString -> UnicodeString -> Bool Source #

(<=) :: UnicodeString -> UnicodeString -> Bool Source #

(>) :: UnicodeString -> UnicodeString -> Bool Source #

(>=) :: UnicodeString -> UnicodeString -> Bool Source #

max :: UnicodeString -> UnicodeString -> UnicodeString Source #

min :: UnicodeString -> UnicodeString -> UnicodeString Source #

Read UnicodeString |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS UnicodeString Source # readList :: ReadS [UnicodeString] Source # readPrec :: ReadPrec UnicodeString Source # readListPrec :: ReadPrec [UnicodeString] Source #
Show UnicodeString |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> UnicodeString -> ShowS Source # show :: UnicodeString -> String Source # showList :: [UnicodeString] -> ShowS Source #
Arbitrary UnicodeString |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen UnicodeString Source # shrink :: UnicodeString -> [UnicodeString] Source #

newtype PrintableString Source #

`PrintableString`: generates a printable unicode String. The string will not contain surrogate pairs.

Constructors

PrintableString |

Fields

- getPrintableString :: String

Instances

Eq PrintableString |
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: PrintableString -> PrintableString -> Bool Source # (/=) :: PrintableString -> PrintableString -> Bool Source #
Ord PrintableString |

Instance details

Defined in Test.QuickCheck.Modifiers

Methods

compare :: PrintableString -> PrintableString -> Ordering Source #

(<) :: PrintableString -> PrintableString -> Bool Source #

(<=) :: PrintableString -> PrintableString -> Bool Source #

(>) :: PrintableString -> PrintableString -> Bool Source #

(>=) :: PrintableString -> PrintableString -> Bool Source #

max :: PrintableString -> PrintableString -> PrintableString Source #

min :: PrintableString -> PrintableString -> PrintableString Source #

Read PrintableString |
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS PrintableString Source # readList :: ReadS [PrintableString] Source # readPrec :: ReadPrec PrintableString Source # readListPrec :: ReadPrec [PrintableString] Source #
Show PrintableString |
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> PrintableString -> ShowS Source # show :: PrintableString -> String Source # showList :: [PrintableString] -> ShowS Source #
Arbitrary PrintableString |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen PrintableString Source # shrink :: PrintableString -> [PrintableString] Source #

infiniteList :: Arbitrary a => Gen [a] Source #

Generates an infinite list.

orderedList :: (Ord a, Arbitrary a) => Gen [a] Source #

Generates an ordered list.

vector :: Arbitrary a => Int -> Gen [a] Source #

Generates a list of a given length.

coarbitraryEnum :: Enum a => a -> Gen b -> Gen b Source #

A `coarbitrary` implementation for enums.

coarbitraryShow :: Show a => a -> Gen b -> Gen b Source #

`coarbitrary` helper for lazy people :-).

coarbitraryReal :: Real a => a -> Gen b -> Gen b Source #

A `coarbitrary` implementation for real numbers.

coarbitraryIntegral :: Integral a => a -> Gen b -> Gen b Source #

A `coarbitrary` implementation for integral numbers.

(><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> Gen a -> Gen a Source #

Combine two generator perturbing functions, for example the results of calls to `variant` or `coarbitrary`.

genericCoarbitrary :: (Generic a, GCoArbitrary (Rep a)) => a -> Gen b -> Gen b Source #

Generic CoArbitrary implementation.

shrinkDecimal :: RealFrac a => a -> [a] Source #

Shrink a real number, preferring numbers with shorter decimal representations. See also `shrinkRealFrac`.

shrinkRealFrac :: RealFrac a => a -> [a] Source #

Shrink a fraction, preferring numbers with smaller numerators or denominators. See also `shrinkDecimal`.

shrinkIntegral :: Integral a => a -> [a] Source #

Shrink an integral number.

shrinkMapBy :: (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b] Source #

Non-overloaded version of `shrinkMap`.

shrinkMap :: Arbitrary a => (a -> b) -> (b -> a) -> b -> [b] Source #

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

shrinkNothing :: a -> [a] Source #

Returns no shrinking alternatives.

arbitraryPrintableChar :: Gen Char Source #

Generates a printable Unicode character.

arbitraryASCIIChar :: Gen Char Source #

Generates a random ASCII character (0-127).

arbitraryUnicodeChar :: Gen Char Source #

Generates any Unicode character (but not a surrogate)

arbitrarySizedBoundedIntegral :: (Bounded a, Integral a) => Gen a Source #

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.

arbitraryBoundedEnum :: (Bounded a, Enum a) => Gen a Source #

Generates an element of a bounded enumeration.

arbitraryBoundedRandom :: (Bounded a, Random a) => Gen a Source #

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

arbitraryBoundedIntegral :: (Bounded a, Integral a) => Gen a Source #

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

arbitrarySizedFractional :: Fractional a => Gen a Source #

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

arbitrarySizedNatural :: Integral a => Gen a Source #

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

arbitrarySizedIntegral :: Integral a => Gen a Source #

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

applyArbitrary4 :: (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => (a -> b -> c -> d -> r) -> Gen r Source #

Apply a function of arity 4 to random arguments.

applyArbitrary3 :: (Arbitrary a, Arbitrary b, Arbitrary c) => (a -> b -> c -> r) -> Gen r Source #

Apply a ternary function to random arguments.

applyArbitrary2 :: (Arbitrary a, Arbitrary b) => (a -> b -> r) -> Gen r Source #

Apply a binary function to random arguments.

shrinkList :: (a -> [a]) -> [a] -> [[a]] Source #

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

subterms :: (Generic a, GSubterms (Rep a) a) => a -> [a] Source #

All immediate subterms of a term.

recursivelyShrink :: (Generic a, RecursivelyShrink (Rep a)) => a -> [a] Source #

Recursively shrink all immediate subterms.

genericShrink :: (Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) => a -> [a] Source #

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

shrink2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => f a b -> [f a b] Source #

arbitrary2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => Gen (f a b) Source #

shrink1 :: (Arbitrary1 f, Arbitrary a) => f a -> [f a] Source #

arbitrary1 :: (Arbitrary1 f, Arbitrary a) => Gen (f a) Source #

class Arbitrary a where Source #

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.

Minimal complete definition

arbitrary

Methods

arbitrary :: Gen a Source #

A generator for values of the given type.

It is worth spending time thinking about what sort of test data you want - good generators are often the difference between finding bugs and not finding them. You can use `sample`, `label` and `classify` to check the quality of your test data.

There is no generic `arbitrary` implementation included because we don't know how to make a high-quality one. If you want one, consider using the testing-feat or generic-random packages.

The QuickCheck manual goes into detail on how to write good generators. Make sure to look at it, especially if your type is recursive!

shrink :: a -> [a] Source #

Produces a (possibly) empty list of all the possible immediate shrinks of the given value.

The default implementation returns the empty list, so will not try to shrink the value. If your data type has no special invariants, you can enable shrinking by defining `shrink = `genericShrink``, but by customising the behaviour of `shrink` you can often get simpler counterexamples.

Most implementations of `shrink` should try at least three things:

1. Shrink a term to any of its immediate subterms. You can use `subterms` to do this.
2. Recursively apply `shrink` to all immediate subterms. You can use `recursivelyShrink` to do this.
3. Type-specific shrinkings such as replacing a constructor by a simpler constructor.

For example, suppose we have the following implementation of binary trees:

    data Tree a = Nil | Branch a (Tree a) (Tree a)

We can then define `shrink` as follows:

    shrink Nil = []
    shrink (Branch x l r) =
      -- shrink Branch to Nil
      [Nil] ++
      -- shrink to subterms
      [l, r] ++
      -- recursively shrink subterms
      [Branch x' l' r' | (x', l', r') <- shrink (x, l, r)]

There are a couple of subtleties here:

- QuickCheck tries the shrinking candidates in the order they appear in the list, so we put more aggressive shrinking steps (such as replacing the whole tree by `Nil`) before smaller ones (such as recursively shrinking the subtrees).
- It is tempting to write the last line as `[Branch x' l' r' | x' <- shrink x, l' <- shrink l, r' <- shrink r]` but this is the wrong thing! It will force QuickCheck to shrink `x`, `l` and `r` in tandem, and shrinking will stop once one of the three is fully shrunk.

There is a fair bit of boilerplate in the code above. We can avoid it with the help of some generic functions. The function `genericShrink` tries shrinking a term to all of its subterms and, failing that, recursively shrinks the subterms. Using it, we can define `shrink` as:

    shrink x = shrinkToNil x ++ genericShrink x
      where
        shrinkToNil Nil = []
        shrinkToNil (Branch _ l r) = [Nil]

`genericShrink` is a combination of `subterms`, which shrinks a term to any of its subterms, and `recursivelyShrink`, which shrinks all subterms of a term. These may be useful if you need a bit more control over shrinking than `genericShrink` gives you.

A final gotcha: we cannot define `shrink` as simply ``shrink` x = Nil:`genericShrink` x` as this shrinks `Nil` to `Nil`, and shrinking will go into an infinite loop.

If all this leaves you bewildered, you might try ``shrink` = `genericShrink`` to begin with, after deriving `Generic` for your type. However, if your data type has any special invariants, you will need to check that `genericShrink` can't break those invariants.

Instances

Arbitrary Bool |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Bool Source # shrink :: Bool -> [Bool] Source #
Arbitrary Char |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Char Source # shrink :: Char -> [Char] Source #
Arbitrary Double |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Double Source # shrink :: Double -> [Double] Source #
Arbitrary Float |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Float Source # shrink :: Float -> [Float] Source #
Arbitrary Int |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int Source # shrink :: Int -> [Int] Source #
Arbitrary Int8 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int8 Source # shrink :: Int8 -> [Int8] Source #
Arbitrary Int16 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int16 Source # shrink :: Int16 -> [Int16] Source #
Arbitrary Int32 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int32 Source # shrink :: Int32 -> [Int32] Source #
Arbitrary Int64 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int64 Source # shrink :: Int64 -> [Int64] Source #
Arbitrary Integer |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Integer Source # shrink :: Integer -> [Integer] Source #
Arbitrary Ordering |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Ordering Source # shrink :: Ordering -> [Ordering] Source #
Arbitrary Word |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word Source # shrink :: Word -> [Word] Source #
Arbitrary Word8 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word8 Source # shrink :: Word8 -> [Word8] Source #
Arbitrary Word16 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word16 Source # shrink :: Word16 -> [Word16] Source #
Arbitrary Word32 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word32 Source # shrink :: Word32 -> [Word32] Source #
Arbitrary Word64 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word64 Source # shrink :: Word64 -> [Word64] Source #
Arbitrary () |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen () Source # shrink :: () -> [()] Source #
Arbitrary Version | Generates `Version` with non-empty non-negative `versionBranch`, and empty `versionTags`
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Version Source # shrink :: Version -> [Version] Source #
Arbitrary QCGen |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen QCGen Source # shrink :: QCGen -> [QCGen] Source #
Arbitrary ASCIIString |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen ASCIIString Source # shrink :: ASCIIString -> [ASCIIString] Source #
Arbitrary UnicodeString |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen UnicodeString Source # shrink :: UnicodeString -> [UnicodeString] Source #
Arbitrary PrintableString |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen PrintableString Source # shrink :: PrintableString -> [PrintableString] Source #
Arbitrary ExitCode |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen ExitCode Source # shrink :: ExitCode -> [ExitCode] Source #
Arbitrary All |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen All Source # shrink :: All -> [All] Source #
Arbitrary Any |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Any Source # shrink :: Any -> [Any] Source #
Arbitrary CChar |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CChar Source # shrink :: CChar -> [CChar] Source #
Arbitrary CSChar |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CSChar Source # shrink :: CSChar -> [CSChar] Source #
Arbitrary CUChar |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUChar Source # shrink :: CUChar -> [CUChar] Source #
Arbitrary CShort |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CShort Source # shrink :: CShort -> [CShort] Source #
Arbitrary CUShort |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUShort Source # shrink :: CUShort -> [CUShort] Source #
Arbitrary CInt |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CInt Source # shrink :: CInt -> [CInt] Source #
Arbitrary CUInt |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUInt Source # shrink :: CUInt -> [CUInt] Source #
Arbitrary CLong |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CLong Source # shrink :: CLong -> [CLong] Source #
Arbitrary CULong |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CULong Source # shrink :: CULong -> [CULong] Source #
Arbitrary CLLong |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CLLong Source # shrink :: CLLong -> [CLLong] Source #
Arbitrary CULLong |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CULLong Source # shrink :: CULLong -> [CULLong] Source #
Arbitrary CFloat |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CFloat Source # shrink :: CFloat -> [CFloat] Source #
Arbitrary CDouble |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CDouble Source # shrink :: CDouble -> [CDouble] Source #
Arbitrary CPtrdiff |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CPtrdiff Source # shrink :: CPtrdiff -> [CPtrdiff] Source #
Arbitrary CSize |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CSize Source # shrink :: CSize -> [CSize] Source #
Arbitrary CWchar |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CWchar Source # shrink :: CWchar -> [CWchar] Source #
Arbitrary CSigAtomic |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CSigAtomic Source # shrink :: CSigAtomic -> [CSigAtomic] Source #
Arbitrary CClock |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CClock Source # shrink :: CClock -> [CClock] Source #
Arbitrary CTime |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CTime Source # shrink :: CTime -> [CTime] Source #
Arbitrary CUSeconds |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUSeconds Source # shrink :: CUSeconds -> [CUSeconds] Source #
Arbitrary CSUSeconds |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CSUSeconds Source # shrink :: CSUSeconds -> [CSUSeconds] Source #
Arbitrary CIntPtr |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CIntPtr Source # shrink :: CIntPtr -> [CIntPtr] Source #
Arbitrary CUIntPtr |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUIntPtr Source # shrink :: CUIntPtr -> [CUIntPtr] Source #
Arbitrary CIntMax |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CIntMax Source # shrink :: CIntMax -> [CIntMax] Source #
Arbitrary CUIntMax |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUIntMax Source # shrink :: CUIntMax -> [CUIntMax] Source #
Arbitrary IntSet |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen IntSet Source # shrink :: IntSet -> [IntSet] Source #
Arbitrary a => Arbitrary [a] |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen [a] Source # shrink :: [a] -> [[a]] Source #
Arbitrary a => Arbitrary (Maybe a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Maybe a) Source # shrink :: Maybe a -> [Maybe a] Source #
Integral a => Arbitrary (Ratio a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Ratio a) Source # shrink :: Ratio a -> [Ratio a] Source #
Arbitrary a => Arbitrary (Blind a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Blind a) Source # shrink :: Blind a -> [Blind a] Source #
Arbitrary a => Arbitrary (Fixed a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Fixed a) Source # shrink :: Fixed a -> [Fixed a] Source #
(Ord a, Arbitrary a) => Arbitrary (OrderedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (OrderedList a) Source # shrink :: OrderedList a -> [OrderedList a] Source #
Arbitrary a => Arbitrary (NonEmptyList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonEmptyList a) Source # shrink :: NonEmptyList a -> [NonEmptyList a] Source #
Arbitrary a => Arbitrary (InfiniteList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (InfiniteList a) Source # shrink :: InfiniteList a -> [InfiniteList a] Source #
(Arbitrary a, Ord a) => Arbitrary (SortedList a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (SortedList a) Source # shrink :: SortedList a -> [SortedList a] Source #
(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Positive a) Source # shrink :: Positive a -> [Positive a] Source #
(Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonZero a) Source # shrink :: NonZero a -> [NonZero a] Source #
(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonNegative a) Source # shrink :: NonNegative a -> [NonNegative a] Source #
(Integral a, Bounded a) => Arbitrary (Large a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Large a) Source # shrink :: Large a -> [Large a] Source #
Integral a => Arbitrary (Small a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Small a) Source # shrink :: Small a -> [Small a] Source #
Arbitrary a => Arbitrary (Shrink2 a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Shrink2 a) Source # shrink :: Shrink2 a -> [Shrink2 a] Source #
Arbitrary a => Arbitrary (Smart a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Smart a) Source # shrink :: Smart a -> [Smart a] Source #
(RealFloat a, Arbitrary a) => Arbitrary (Complex a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Complex a) Source # shrink :: Complex a -> [Complex a] Source #
HasResolution a => Arbitrary (Fixed a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Fixed a) Source # shrink :: Fixed a -> [Fixed a] Source #
Arbitrary a => Arbitrary (ZipList a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (ZipList a) Source # shrink :: ZipList a -> [ZipList a] Source #
Arbitrary a => Arbitrary (Identity a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Identity a) Source # shrink :: Identity a -> [Identity a] Source #
Arbitrary a => Arbitrary (First a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (First a) Source # shrink :: First a -> [First a] Source #
Arbitrary a => Arbitrary (Last a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Last a) Source # shrink :: Last a -> [Last a] Source #
Arbitrary a => Arbitrary (Dual a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Dual a) Source # shrink :: Dual a -> [Dual a] Source #
(Arbitrary a, CoArbitrary a) => Arbitrary (Endo a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Endo a) Source # shrink :: Endo a -> [Endo a] Source #
Arbitrary a => Arbitrary (Sum a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Sum a) Source # shrink :: Sum a -> [Sum a] Source #
Arbitrary a => Arbitrary (Product a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Product a) Source # shrink :: Product a -> [Product a] Source #
Arbitrary a => Arbitrary (IntMap a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (IntMap a) Source # shrink :: IntMap a -> [IntMap a] Source #
Arbitrary a => Arbitrary (Seq a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Seq a) Source # shrink :: Seq a -> [Seq a] Source #
(Ord a, Arbitrary a) => Arbitrary (Set a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Set a) Source # shrink :: Set a -> [Set a] Source #
Arbitrary a => Arbitrary (InfiniteListInternalData a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (InfiniteListInternalData a) Source # shrink :: InfiniteListInternalData a -> [InfiniteListInternalData a] Source #
(CoArbitrary a, Arbitrary b) => Arbitrary (a -> b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a -> b) Source # shrink :: (a -> b) -> [a -> b] Source #
(Arbitrary a, Arbitrary b) => Arbitrary (Either a b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Either a b) Source # shrink :: Either a b -> [Either a b] Source #
(Arbitrary a, Arbitrary b) => Arbitrary (a, b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b) Source # shrink :: (a, b) -> [(a, b)] Source #
(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (a :-> b) |
Instance details Defined in Test.QuickCheck.Function Methods arbitrary :: Gen (a :-> b) Source # shrink :: (a :-> b) -> [a :-> b] Source #
(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (Fun a b) |
Instance details Defined in Test.QuickCheck.Function Methods arbitrary :: Gen (Fun a b) Source # shrink :: Fun a b -> [Fun a b] Source #
(Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a) |
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Shrinking s a) Source # shrink :: Shrinking s a -> [Shrinking s a] Source #
Arbitrary (m a) => Arbitrary (WrappedMonad m a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (WrappedMonad m a) Source # shrink :: WrappedMonad m a -> [WrappedMonad m a] Source #
(Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map k v) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Map k v) Source # shrink :: Map k v -> [Map k v] Source #
(Arbitrary a, Arbitrary b, Arbitrary c) => Arbitrary (a, b, c) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c) Source # shrink :: (a, b, c) -> [(a, b, c)] Source #
Arbitrary (a b c) => Arbitrary (WrappedArrow a b c) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (WrappedArrow a b c) Source # shrink :: WrappedArrow a b c -> [WrappedArrow a b c] Source #
Arbitrary a => Arbitrary (Const a b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Const a b) Source # shrink :: Const a b -> [Const a b] Source #
Arbitrary (f a) => Arbitrary (Alt f a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Alt f a) Source # shrink :: Alt f a -> [Alt f a] Source #
Arbitrary a => Arbitrary (Constant a b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Constant a b) Source # shrink :: Constant a b -> [Constant a b] Source #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => Arbitrary (a, b, c, d) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d) Source # shrink :: (a, b, c, d) -> [(a, b, c, d)] Source #
(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Product f g a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Product f g a) Source # shrink :: Product f g a -> [Product f g a] Source #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) => Arbitrary (a, b, c, d, e) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e) Source # shrink :: (a, b, c, d, e) -> [(a, b, c, d, e)] Source #
(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Compose f g a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Compose f g a) Source # shrink :: Compose f g a -> [Compose f g a] Source #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f) => Arbitrary (a, b, c, d, e, f) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f) Source # shrink :: (a, b, c, d, e, f) -> [(a, b, c, d, e, f)] Source #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g) => Arbitrary (a, b, c, d, e, f, g) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f, g) Source # shrink :: (a, b, c, d, e, f, g) -> [(a, b, c, d, e, f, g)] Source #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h) => Arbitrary (a, b, c, d, e, f, g, h) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f, g, h) Source # shrink :: (a, b, c, d, e, f, g, h) -> [(a, b, c, d, e, f, g, h)] Source #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i) => Arbitrary (a, b, c, d, e, f, g, h, i) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f, g, h, i) Source # shrink :: (a, b, c, d, e, f, g, h, i) -> [(a, b, c, d, e, f, g, h, i)] Source #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i, Arbitrary j) => Arbitrary (a, b, c, d, e, f, g, h, i, j) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f, g, h, i, j) Source # shrink :: (a, b, c, d, e, f, g, h, i, j) -> [(a, b, c, d, e, f, g, h, i, j)] Source #

class Arbitrary1 (f :: Type -> Type) where Source #

Lifting of the `Arbitrary` class to unary type constructors.

Minimal complete definition

liftArbitrary

Methods

liftArbitrary :: Gen a -> Gen (f a) Source #

liftShrink :: (a -> [a]) -> f a -> [f a] Source #

Instances

Arbitrary1 [] |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen [a] Source # liftShrink :: (a -> [a]) -> [a] -> [[a]] Source #
Arbitrary1 Maybe |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Maybe a) Source # liftShrink :: (a -> [a]) -> Maybe a -> [Maybe a] Source #
Arbitrary1 ZipList |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (ZipList a) Source # liftShrink :: (a -> [a]) -> ZipList a -> [ZipList a] Source #
Arbitrary1 Identity |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Identity a) Source # liftShrink :: (a -> [a]) -> Identity a -> [Identity a] Source #
Arbitrary1 IntMap |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (IntMap a) Source # liftShrink :: (a -> [a]) -> IntMap a -> [IntMap a] Source #
Arbitrary1 Seq |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Seq a) Source # liftShrink :: (a -> [a]) -> Seq a -> [Seq a] Source #
Arbitrary a => Arbitrary1 (Either a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (Either a a0) Source # liftShrink :: (a0 -> [a0]) -> Either a a0 -> [Either a a0] Source #
Arbitrary a => Arbitrary1 ((,) a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (a, a0) Source # liftShrink :: (a0 -> [a0]) -> (a, a0) -> [(a, a0)] Source #
(Ord k, Arbitrary k) => Arbitrary1 (Map k) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Map k a) Source # liftShrink :: (a -> [a]) -> Map k a -> [Map k a] Source #
Arbitrary a => Arbitrary1 (Const a :: Type -> Type) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (Const a a0) Source # liftShrink :: (a0 -> [a0]) -> Const a a0 -> [Const a a0] Source #
Arbitrary a => Arbitrary1 (Constant a :: Type -> Type) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (Constant a a0) Source # liftShrink :: (a0 -> [a0]) -> Constant a a0 -> [Constant a a0] Source #
CoArbitrary a => Arbitrary1 ((->) a :: Type -> Type) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (a -> a0) Source # liftShrink :: (a0 -> [a0]) -> (a -> a0) -> [a -> a0] Source #
(Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Product f g) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Product f g a) Source # liftShrink :: (a -> [a]) -> Product f g a -> [Product f g a] Source #
(Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Compose f g) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Compose f g a) Source # liftShrink :: (a -> [a]) -> Compose f g a -> [Compose f g a] Source #

class Arbitrary2 (f :: Type -> Type -> Type) where Source #

Lifting of the `Arbitrary` class to binary type constructors.

Minimal complete definition

liftArbitrary2

Methods

liftArbitrary2 :: Gen a -> Gen b -> Gen (f a b) Source #

liftShrink2 :: (a -> [a]) -> (b -> [b]) -> f a b -> [f a b] Source #

Instances

Arbitrary2 Either |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (Either a b) Source # liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Either a b -> [Either a b] Source #
Arbitrary2 (,) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (a, b) Source # liftShrink2 :: (a -> [a]) -> (b -> [b]) -> (a, b) -> [(a, b)] Source #
Arbitrary2 (Const :: Type -> Type -> Type) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (Const a b) Source # liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Const a b -> [Const a b] Source #
Arbitrary2 (Constant :: Type -> Type -> Type) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (Constant a b) Source # liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Constant a b -> [Constant a b] Source #

class CoArbitrary a where Source #

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)`.

Minimal complete definition

Nothing

Methods

coarbitrary :: a -> Gen b -> Gen b Source #

Used to generate a function of type `a -> b`. The first argument is a value, the second a generator. You should use `variant` to perturb the random generator; the goal is that different values for the first argument will lead to different calls to `variant`. An example will help:

    instance CoArbitrary a => CoArbitrary [a] where
      coarbitrary []     = variant 0
      coarbitrary (x:xs) = variant 1 . coarbitrary (x,xs)

Instances

CoArbitrary Bool |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Bool -> Gen b -> Gen b Source #
CoArbitrary Char |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Char -> Gen b -> Gen b Source #
CoArbitrary Double |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Double -> Gen b -> Gen b Source #
CoArbitrary Float |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Float -> Gen b -> Gen b Source #
CoArbitrary Int |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int -> Gen b -> Gen b Source #
CoArbitrary Int8 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int8 -> Gen b -> Gen b Source #
CoArbitrary Int16 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int16 -> Gen b -> Gen b Source #
CoArbitrary Int32 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int32 -> Gen b -> Gen b Source #
CoArbitrary Int64 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int64 -> Gen b -> Gen b Source #
CoArbitrary Integer |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Integer -> Gen b -> Gen b Source #
CoArbitrary Ordering |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Ordering -> Gen b -> Gen b Source #
CoArbitrary Word |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word -> Gen b -> Gen b Source #
CoArbitrary Word8 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word8 -> Gen b -> Gen b Source #
CoArbitrary Word16 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word16 -> Gen b -> Gen b Source #
CoArbitrary Word32 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word32 -> Gen b -> Gen b Source #
CoArbitrary Word64 |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word64 -> Gen b -> Gen b Source #
CoArbitrary () |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: () -> Gen b -> Gen b Source #
CoArbitrary Version |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Version -> Gen b -> Gen b Source #
CoArbitrary All |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: All -> Gen b -> Gen b Source #
CoArbitrary Any |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Any -> Gen b -> Gen b Source #
CoArbitrary IntSet |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: IntSet -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary [a] |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: [a] -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Maybe a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Maybe a -> Gen b -> Gen b Source #
(Integral a, CoArbitrary a) => CoArbitrary (Ratio a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Ratio a -> Gen b -> Gen b Source #
(RealFloat a, CoArbitrary a) => CoArbitrary (Complex a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Complex a -> Gen b -> Gen b Source #
HasResolution a => CoArbitrary (Fixed a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Fixed a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (ZipList a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: ZipList a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Identity a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Identity a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (First a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: First a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Last a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Last a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Dual a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Dual a -> Gen b -> Gen b Source #
(Arbitrary a, CoArbitrary a) => CoArbitrary (Endo a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Endo a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Sum a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Sum a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Product a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Product a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (IntMap a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: IntMap a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Seq a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Seq a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Set a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Set a -> Gen b -> Gen b Source #
(Arbitrary a, CoArbitrary b) => CoArbitrary (a -> b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a -> b) -> Gen b0 -> Gen b0 Source #
(CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Either a b -> Gen b0 -> Gen b0 Source #
(CoArbitrary a, CoArbitrary b) => CoArbitrary (a, b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a, b) -> Gen b0 -> Gen b0 Source #
(CoArbitrary k, CoArbitrary v) => CoArbitrary (Map k v) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Map k v -> Gen b -> Gen b Source #
(CoArbitrary a, CoArbitrary b, CoArbitrary c) => CoArbitrary (a, b, c) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a, b, c) -> Gen b0 -> Gen b0 Source #
CoArbitrary a => CoArbitrary (Const a b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Const a b -> Gen b0 -> Gen b0 Source #
CoArbitrary (f a) => CoArbitrary (Alt f a) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Alt f a -> Gen b -> Gen b Source #
CoArbitrary a => CoArbitrary (Constant a b) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Constant a b -> Gen b0 -> Gen b0 Source #
(CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d) => CoArbitrary (a, b, c, d) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a, b, c, d) -> Gen b0 -> Gen b0 Source #
(CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d, CoArbitrary e) => CoArbitrary (a, b, c, d, e) |
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a, b, c, d, e) -> Gen b0 -> Gen b0 Source #

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

Generates an infinite list.

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

Generates a list of the given length.

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

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

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

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

growingElements :: [a] -> Gen a Source #

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.

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

Generates a random permutation of the given list.

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

Generates a random subsequence of the given list.

elements :: [a] -> Gen a Source #

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

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

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

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

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

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

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

suchThatMap :: Gen a -> (a -> Maybe b) -> Gen b Source #

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

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

Generates a value that satisfies a predicate.

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

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

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

Generates some example values.

generate :: Gen a -> IO a Source #

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

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

Generates a random element in the given inclusive range.

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

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

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

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

getSize :: Gen Int Source #

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`.

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

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`.

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

Modifies a generator using an integer seed.

data Gen a Source #

A generator for values of type `a`.

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

Instances

Monad Gen |
Instance details Defined in Test.QuickCheck.Gen Methods (>>=) :: Gen a -> (a -> Gen b) -> Gen b Source # (>>) :: Gen a -> Gen b -> Gen b Source # return :: a -> Gen a Source # fail :: String -> Gen a Source #
Functor Gen |
Instance details Defined in Test.QuickCheck.Gen Methods fmap :: (a -> b) -> Gen a -> Gen b Source # (<$) :: a -> Gen b -> Gen a Source #
MonadFix Gen |
Instance details Defined in Test.QuickCheck.Gen Methods mfix :: (a -> Gen a) -> Gen a Source #
Applicative Gen |
Instance details Defined in Test.QuickCheck.Gen Methods pure :: a -> Gen a Source # (<*>) :: Gen (a -> b) -> Gen a -> Gen b Source # liftA2 :: (a -> b -> c) -> Gen a -> Gen b -> Gen c Source # (*>) :: Gen a -> Gen b -> Gen b Source # (<*) :: Gen a -> Gen b -> Gen a Source #
Testable prop => Testable (Gen prop) |
Instance details Defined in Test.QuickCheck.Property Methods property :: Gen prop -> Property Source #

discard :: a Source #

A special error value. If a property evaluates `discard`, it causes QuickCheck to discard the current test case. This can be useful if you want to discard the current test case, but are somewhere you can't use `==>`, such as inside a generator.

# Internal

If you are building a test suite, you don't need these functions.

They may be used by other tasty add-on packages (such as tasty-hspec).

newtype QC Source #

Constructors

QC Property |

Instances

IsTest QC Source # |
Instance details Defined in Test.Tasty.QuickCheck Methods run :: OptionSet -> QC -> (Progress -> IO ()) -> IO Result Source # testOptions :: Tagged QC [OptionDescription] Source #

optionSetToArgs :: OptionSet -> IO (Int, Args) Source #

Convert tasty options into QuickCheck options.

This is a low-level function that was originally added for tasty-hspec but may be used by others.

Since: 0.9.1