-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Get counterexamples from QuickCheck as Haskell values
--
-- When QuickCheck finds a counterexample, it prints it out but doesn't
-- save it so that the programmer can access it. This can be annoying
-- when debugging.
--
-- This library provides a small extension to QuickCheck that returns
-- counterexamples as normal Haskell values. To use it, just import
-- Test.QuickCheck.Counterexamples instead of
-- Test.QuickCheck. The library is largely compatible with
-- normal QuickCheck, but the return types of
-- Test.QuickCheck.Counterexamples.quickCheck and related
-- functions are changed to include a counterexample.
--
-- For usage information, see the Test.QuickCheck.Counterexamples
-- module.
@package quickcheck-with-counterexamples
@version 1.2
-- | This module extends QuickCheck so that it returns counterexamples as
-- Haskell values instead of just printing them. To use it, import this
-- module instead of Test.QuickCheck. The API and
-- functionality are the same as normal QuickCheck; the only difference
-- is that the return types of quickCheck (and related functions)
-- include a counterexample.
--
-- Note that this module re-exports most functions from
-- Test.QuickCheck. Those functions are not documented
-- here! You will need to refer to the main Test.QuickCheck
-- documentation when using this module.
--
-- Here is an example of getting counterexamples. Suppose we have the
-- following property:
--
--
-- prop_reverse_append :: [Int] -> [Int] -> Property
-- prop_reverse_append xs ys =
-- reverse (xs++ys) === reverse xs ++ reverse ys
--
--
-- If we look the type of quickCheck prop_reverse_append, we see
-- that it returns a counterexample:
--
--
-- >>> :t quickCheck prop_reverse_append
-- quickCheck prop_reverse_append :: IO (Maybe ([Int] :&: [Int] :&: ()))
--
--
-- The Maybe is there because quickCheck will return
-- Nothing if the property succeeds; :&: is a datatype
-- of pairs.
--
-- If we run QuickCheck, we can get the counterexample as a normal
-- Haskell value:
--
--
-- >>> Just (xs :&: ys :&: ()) <- quickCheck prop_reverse_append
-- *** Failed! Falsifiable (after 5 tests and 4 shrinks):
-- [0]
-- [1]
-- [1,0] /= [0,1]
--
--
--
-- >>> :t xs
-- xs :: [Int]
--
--
--
-- >>> xs
-- [0]
--
--
--
-- >>> ys
-- [1]
--
--
-- If you use counterexample in your property, the string you pass
-- won't be returned as a Haskell value. You might instead want to use
-- typedCounterexample, which adds a Haskell value to the
-- counterexample (but doesn't print it).
--
-- That ought to be all you need to know to use this module. If you want
-- all the details, here is how this module alters QuickCheck's API:
--
--
module Test.QuickCheck.Counterexamples
-- | A type of pairs. Used in counterexamples.
data a :&: b
(:&:) :: a -> b -> (:&:) a b
infixr 6 :&:
infixr 6 :&:
-- | The class of properties, i.e. types which QuickCheck knows how to
-- test.
class Testable prop => Testable prop where {
-- | The type of counterexamples to the property.
type family Counterexample prop;
}
-- | Convert the property to a PropertyOf.
property :: Testable prop => prop -> PropertyFrom prop
-- | See propertyForAllShrinkShow.
propertyForAllShrinkShow :: (Testable prop, Show a) => Gen a -> (a -> [a]) -> (a -> String) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)
-- | A type synonym for the property which comes from a particular
-- Testable instance.
type PropertyFrom prop = PropertyOf (Counterexample prop)
-- | A property which doesn't produce a counterexample.
type Property = PropertyOf ()
-- | A property. cex is the type of counterexamples to the
-- property.
--
-- Note that there is a Functor instance, which is useful when you
-- want to manipulate the counterexample, e.g., to change its type. For
-- example, when some branches of your property produce a counterexample
-- and other branches do not, the types will not match up, but using
-- fmap you can make the counterexample be a Maybe.
newtype PropertyOf cex
MkProperty :: ((cex -> IO ()) -> Property) -> PropertyOf cex
-- | Implementation note: the property receives a callback to which it
-- should pass the counterexample after shrinking.
[unProperty] :: PropertyOf cex -> (cex -> IO ()) -> Property
-- | Add a value to the counterexample. The value is not printed as part of
-- the counterexample; if you want it to be, use counterexample as
-- well.
typedCounterexample :: Testable prop => a -> prop -> PropertyOf (a :&: Counterexample prop)
-- | Lift an ordinary QuickCheck property combinator to one with
-- counterexamples.
onProperty :: Testable prop => (Property -> Property) -> prop -> PropertyFrom prop
-- | See quickCheck in Test.QuickCheck.
quickCheck :: Testable prop => prop -> IO (Maybe (Counterexample prop))
-- | See quickCheckWith in Test.QuickCheck.
quickCheckWith :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop))
-- | See quickCheckResult in Test.QuickCheck.
quickCheckResult :: Testable prop => prop -> IO (Maybe (Counterexample prop), Result)
-- | See quickCheckWithResult in Test.QuickCheck.
quickCheckWithResult :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop), Result)
-- | See verboseCheck in Test.QuickCheck.
verboseCheck :: Testable prop => prop -> IO (Maybe (Counterexample prop))
-- | See verboseCheckWith in Test.QuickCheck.
verboseCheckWith :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop))
-- | See verboseCheckResult in Test.QuickCheck.
verboseCheckResult :: Testable prop => prop -> IO (Maybe (Counterexample prop), Result)
-- | See verboseCheckWithResult in Test.QuickCheck.
verboseCheckWithResult :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop), Result)
-- | See labelledExamples in Test.QuickCheck.
labelledExamples :: Testable prop => prop -> IO (Maybe (Counterexample prop))
-- | See labelledExamplesWith in Test.QuickCheck.
labelledExamplesWith :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop))
-- | See labelledExamplesResult in Test.QuickCheck.
labelledExamplesResult :: Testable prop => prop -> IO (Maybe (Counterexample prop), Result)
-- | See labelledExamplesWithResult in Test.QuickCheck.
labelledExamplesWithResult :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop), Result)
-- | See polyQuickCheck in Test.QuickCheck.
polyQuickCheck :: Name -> ExpQ
-- | See polyVerboseCheck in Test.QuickCheck.
polyVerboseCheck :: Name -> ExpQ
-- | See forAll in Test.QuickCheck.
forAll :: (Testable prop, Show a) => Gen a -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)
-- | See forAllShrink in Test.QuickCheck.
forAllShrink :: (Testable prop, Show a) => Gen a -> (a -> [a]) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)
-- | See forAllShow in Test.QuickCheck.
forAllShow :: Testable prop => Gen a -> (a -> String) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)
-- | See forAllShrinkShow in Test.QuickCheck.
forAllShrinkShow :: Testable prop => Gen a -> (a -> [a]) -> (a -> String) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)
-- | See forAllBlind in Test.QuickCheck.
forAllBlind :: Testable prop => Gen a -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)
-- | See forAllShrinkBlind in Test.QuickCheck.
forAllShrinkBlind :: Testable prop => Gen a -> (a -> [a]) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)
-- | See shrinking in Test.QuickCheck.
shrinking :: Testable prop => (a -> [a]) -> a -> (a -> prop) -> PropertyFrom prop
-- | See ==> in Test.QuickCheck.
(==>) :: Testable prop => Bool -> prop -> PropertyFrom prop
infixr 0 ==>
-- | See === in Test.QuickCheck.
(===) :: (Eq a, Show a) => a -> a -> Property
infix 4 ===
-- | See =/= in Test.QuickCheck.
(=/=) :: (Eq a, Show a) => a -> a -> Property
infix 4 =/=
-- | See ioProperty in Test.QuickCheck.
ioProperty :: Testable prop => IO prop -> PropertyFrom prop
-- | See idempotentIOProperty in Test.QuickCheck.
idempotentIOProperty :: Testable prop => IO prop -> PropertyFrom prop
-- | See verbose in Test.QuickCheck.
verbose :: Testable prop => prop -> PropertyFrom prop
-- | See verboseShrinking in Test.QuickCheck.
verboseShrinking :: Testable prop => prop -> PropertyFrom prop
-- | See once in Test.QuickCheck.
once :: Testable prop => prop -> PropertyFrom prop
-- | See again in Test.QuickCheck.
again :: Testable prop => prop -> PropertyFrom prop
-- | See within in Test.QuickCheck.
within :: Testable prop => Int -> prop -> PropertyFrom prop
-- | See noShrinking in Test.QuickCheck.
noShrinking :: Testable prop => prop -> PropertyFrom prop
-- | See counterexample in Test.QuickCheck.
counterexample :: Testable prop => String -> prop -> PropertyFrom prop
-- | See whenFail in Test.QuickCheck.
whenFail :: Testable prop => IO () -> prop -> PropertyFrom prop
-- | See whenFail' in Test.QuickCheck.
whenFail' :: Testable prop => IO () -> prop -> PropertyFrom prop
-- | See expectFailure in Test.QuickCheck.
expectFailure :: Testable prop => prop -> PropertyFrom prop
-- | See label in Test.QuickCheck.
label :: Testable prop => String -> prop -> PropertyFrom prop
-- | See collect in Test.QuickCheck.
collect :: (Show a, Testable prop) => a -> prop -> PropertyFrom prop
-- | See classify in Test.QuickCheck.
classify :: Testable prop => Bool -> String -> prop -> PropertyFrom prop
-- | See cover in Test.QuickCheck.
cover :: Testable prop => Double -> Bool -> String -> prop -> PropertyFrom prop
-- | See tabulate in Test.QuickCheck.
tabulate :: Testable prop => String -> [String] -> prop -> PropertyFrom prop
-- | See coverTables in Test.QuickCheck.
coverTables :: Testable prop => String -> [(String, Double)] -> prop -> PropertyFrom prop
-- | See checkCoverage in Test.QuickCheck.
checkCoverage :: Testable prop => prop -> PropertyFrom prop
-- | See checkCoverageWith in Test.QuickCheck.
checkCoverageWith :: Testable prop => Confidence -> prop -> PropertyFrom prop
-- | See mapSize in Test.QuickCheck.
mapSize :: Testable prop => (Int -> Int) -> prop -> PropertyFrom prop
-- | Test all properties in the current module. This is just a convenience
-- function that combines quickCheckAll and verbose.
--
-- verboseCheckAll has the same issue with scoping as
-- quickCheckAll: see the note there about return [].
verboseCheckAll :: Q Exp
-- | Test all properties in the current module. The name of the property
-- must begin with prop_. Polymorphic properties will be
-- defaulted to Integer. Returns True if all tests
-- succeeded, False otherwise.
--
-- To use quickCheckAll, add a definition to your module along the
-- lines of
--
--
-- return []
-- runTests = $quickCheckAll
--
--
-- and then execute runTests.
--
-- Note: the bizarre return [] in the example above is needed on
-- GHC 7.8 and later; without it, quickCheckAll will not be able
-- to find any of the properties. For the curious, the return []
-- is a Template Haskell splice that makes GHC insert the empty list of
-- declarations at that point in the program; GHC typechecks everything
-- before the return [] before it starts on the rest of the
-- module, which means that the later call to quickCheckAll can
-- see everything that was defined before the return []. Yikes!
quickCheckAll :: Q Exp
-- | List all properties in the current module.
--
-- $allProperties has type [(String,
-- Property)].
--
-- allProperties has the same issue with scoping as
-- quickCheckAll: see the note there about return [].
allProperties :: Q Exp
-- | Test all properties in the current module, using a custom
-- quickCheck function. The same caveats as with
-- quickCheckAll apply.
--
-- $forAllProperties has type (Property ->
-- IO Result) -> IO Bool. An example
-- invocation is $forAllProperties
-- quickCheckResult, which does the same thing as
-- $quickCheckAll.
--
-- forAllProperties has the same issue with scoping as
-- quickCheckAll: see the note there about return [].
forAllProperties :: Q Exp
-- | 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 [].
monomorphic :: Name -> ExpQ
-- | The default test arguments
stdArgs :: Args
-- | Check if the test run result was a success
isSuccess :: Result -> Bool
-- | Args specifies arguments to the QuickCheck driver
data Args
Args :: Maybe (QCGen, Int) -> Int -> Int -> Int -> Bool -> Int -> Args
-- | Should we replay a previous test? Note: saving a seed from one version
-- of QuickCheck and replaying it in another is not supported. If you
-- want to store a test case permanently you should save the test case
-- itself.
[replay] :: Args -> Maybe (QCGen, Int)
-- | Maximum number of successful tests before succeeding. Testing stops at
-- the first failure. If all tests are passing and you want to run more
-- tests, increase this number.
[maxSuccess] :: Args -> Int
-- | Maximum number of discarded tests per successful test before giving up
[maxDiscardRatio] :: Args -> Int
-- | Size to use for the biggest test cases
[maxSize] :: Args -> Int
-- | Whether to print anything
[chatty] :: Args -> Bool
-- | Maximum number of shrinks to before giving up. Setting this to zero
-- turns shrinking off.
[maxShrinks] :: Args -> Int
-- | Result represents the test result
data Result
-- | A successful test run
Success :: Int -> Int -> !Map [String] Int -> !Map String Int -> !Map String (Map String Int) -> String -> Result
-- | Number of tests performed
[numTests] :: Result -> Int
-- | Number of tests skipped
[numDiscarded] :: Result -> Int
-- | The number of test cases having each combination of labels (see
-- label)
[labels] :: Result -> !Map [String] Int
-- | The number of test cases having each class (see classify)
[classes] :: Result -> !Map String Int
-- | Data collected by tabulate
[tables] :: Result -> !Map String (Map String Int)
-- | Printed output
[output] :: Result -> String
-- | Given up
GaveUp :: Int -> Int -> !Map [String] Int -> !Map String Int -> !Map String (Map String Int) -> String -> Result
-- | Number of tests performed
[numTests] :: Result -> Int
-- | Number of tests skipped
[numDiscarded] :: Result -> Int
-- | The number of test cases having each combination of labels (see
-- label)
[labels] :: Result -> !Map [String] Int
-- | The number of test cases having each class (see classify)
[classes] :: Result -> !Map String Int
-- | Data collected by tabulate
[tables] :: Result -> !Map String (Map String Int)
-- | Printed output
[output] :: Result -> String
-- | A failed test run
Failure :: Int -> Int -> Int -> Int -> Int -> QCGen -> Int -> String -> Maybe AnException -> String -> [String] -> [String] -> Set String -> Result
-- | Number of tests performed
[numTests] :: Result -> Int
-- | Number of tests skipped
[numDiscarded] :: Result -> Int
-- | Number of successful shrinking steps performed
[numShrinks] :: Result -> Int
-- | Number of unsuccessful shrinking steps performed
[numShrinkTries] :: Result -> Int
-- | Number of unsuccessful shrinking steps performed since last successful
-- shrink
[numShrinkFinal] :: Result -> Int
-- | What seed was used
[usedSeed] :: Result -> QCGen
-- | What was the test size
[usedSize] :: Result -> Int
-- | Why did the property fail
[reason] :: Result -> String
-- | The exception the property threw, if any
[theException] :: Result -> Maybe AnException
-- | Printed output
[output] :: Result -> String
-- | The test case which provoked the failure
[failingTestCase] :: Result -> [String]
-- | The test case's labels (see label)
[failingLabels] :: Result -> [String]
-- | The test case's classes (see classify)
[failingClasses] :: Result -> Set String
-- | A property that should have failed did not
NoExpectedFailure :: Int -> Int -> !Map [String] Int -> !Map String Int -> !Map String (Map String Int) -> String -> Result
-- | Number of tests performed
[numTests] :: Result -> Int
-- | Number of tests skipped
[numDiscarded] :: Result -> Int
-- | The number of test cases having each combination of labels (see
-- label)
[labels] :: Result -> !Map [String] Int
-- | The number of test cases having each class (see classify)
[classes] :: Result -> !Map String Int
-- | Data collected by tabulate
[tables] :: Result -> !Map String (Map String Int)
-- | Printed output
[output] :: Result -> String
-- | Checks that a value is total, i.e., doesn't crash when evaluated.
total :: NFData a => a -> Property
-- | The standard parameters used by checkCoverage: certainty =
-- 10^9, tolerance = 0.9. See Confidence for the
-- meaning of the parameters.
stdConfidence :: Confidence
-- | Configures how many times a property will be tested.
--
-- For example,
--
--
-- quickCheck (withMaxSuccess 1000 p)
--
--
-- will test p up to 1000 times.
withMaxSuccess :: Testable prop => Int -> prop -> Property
-- | 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
--
data Discard
Discard :: Discard
-- | The statistical parameters used by checkCoverage.
data Confidence
Confidence :: Integer -> Double -> Confidence
-- | 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.
[certainty] :: Confidence -> Integer
-- | 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.
[tolerance] :: Confidence -> Double
-- | Extracts the value of a ternary function. Fn3 is the pattern
-- equivalent of this function.
applyFun3 :: () => Fun (a, b, c) d -> a -> b -> c -> d
-- | 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]
--
applyFun2 :: () => Fun (a, b) c -> a -> b -> c
-- | 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"
--
applyFun :: () => Fun a b -> a -> b
-- | The basic building block for Function instances. Provides a
-- Function instance by mapping to and from a type that already
-- has a Function instance.
functionMap :: Function b => (a -> b) -> (b -> a) -> (a -> c) -> a :-> c
-- | Provides a Function instance for types with Show and
-- Read.
functionShow :: (Show a, Read a) => (a -> c) -> a :-> c
-- | Provides a Function instance for types with Integral.
functionIntegral :: Integral a => (a -> b) -> a :-> b
-- | Provides a Function instance for types with RealFrac.
functionRealFrac :: RealFrac a => (a -> b) -> a :-> b
-- | Provides a Function instance for types with Bounded and
-- Enum. Use only for small types (i.e. not integers): creates the
-- list ['minBound'..'maxBound']!
functionBoundedEnum :: (Eq a, Bounded a, Enum a) => (a -> b) -> a :-> b
-- | A modifier for testing functions.
--
--
-- prop :: Fun String Integer -> Bool
-- prop (Fn f) = f "banana" == f "monkey"
-- || f "banana" == f "elephant"
--
pattern Fn :: forall a b. () => () => (a -> b) -> Fun a b
-- | 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 Fn2 :: forall a b c. () => () => (a -> b -> c) -> Fun (a, b) c
-- | A modifier for testing ternary functions.
pattern Fn3 :: forall a b c d. () => () => (a -> b -> c -> d) -> Fun (a, b, c) d
-- | 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.
class Function a
function :: Function a => (a -> b) -> a :-> b
-- | 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.
data Fun a b
Fun :: (a :-> b, b, Shrunk) -> (a -> b) -> Fun a b
-- | Blind x: as x, but x does not have to be in the Show
-- class.
newtype Blind a
Blind :: a -> Blind a
[getBlind] :: Blind a -> a
-- | Fixed x: as x, but will not be shrunk.
newtype Fixed a
Fixed :: a -> Fixed a
[getFixed] :: Fixed a -> a
-- | Ordered xs: guarantees that xs is ordered.
newtype OrderedList a
Ordered :: [a] -> OrderedList a
[getOrdered] :: OrderedList a -> [a]
-- | NonEmpty xs: guarantees that xs is non-empty.
newtype NonEmptyList a
NonEmpty :: [a] -> NonEmptyList a
[getNonEmpty] :: NonEmptyList a -> [a]
-- | 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! Falsified (after 1 test and 14 shrinks):
-- "bbbbbbbbbb" ++ ...
--
data InfiniteList a
InfiniteList :: [a] -> InfiniteListInternalData a -> InfiniteList a
[getInfiniteList] :: InfiniteList a -> [a]
[infiniteListInternalData] :: InfiniteList a -> InfiniteListInternalData a
-- | Sorted xs: guarantees that xs is sorted.
newtype SortedList a
Sorted :: [a] -> SortedList a
[getSorted] :: SortedList a -> [a]
-- | Positive x: guarantees that x > 0.
newtype Positive a
Positive :: a -> Positive a
[getPositive] :: Positive a -> a
-- | Negative x: guarantees that x < 0.
newtype Negative a
Negative :: a -> Negative a
[getNegative] :: Negative a -> a
-- | NonZero x: guarantees that x /= 0.
newtype NonZero a
NonZero :: a -> NonZero a
[getNonZero] :: NonZero a -> a
-- | NonNegative x: guarantees that x >= 0.
newtype NonNegative a
NonNegative :: a -> NonNegative a
[getNonNegative] :: NonNegative a -> a
-- | NonPositive x: guarantees that x <= 0.
newtype NonPositive a
NonPositive :: a -> NonPositive a
[getNonPositive] :: NonPositive a -> a
-- | Large x: by default, QuickCheck generates Ints drawn
-- from a small range. Large Int gives you values drawn from the
-- entire range instead.
newtype Large a
Large :: a -> Large a
[getLarge] :: Large a -> a
-- | Small x: generates values of x drawn from a small
-- range. The opposite of Large.
newtype Small a
Small :: a -> Small a
[getSmall] :: Small a -> a
-- | Shrink2 x: allows 2 shrinking steps at the same time when
-- shrinking x
newtype Shrink2 a
Shrink2 :: a -> Shrink2 a
[getShrink2] :: Shrink2 a -> a
-- | Smart _ x: tries a different order when shrinking.
data Smart a
Smart :: Int -> a -> Smart a
-- | Shrinking _ x: allows for maintaining a state during
-- shrinking.
data Shrinking s a
Shrinking :: s -> a -> Shrinking s a
class ShrinkState s a
shrinkInit :: ShrinkState s a => a -> s
shrinkState :: ShrinkState s a => a -> s -> [(a, s)]
-- | ASCIIString: generates an ASCII string.
newtype ASCIIString
ASCIIString :: String -> ASCIIString
[getASCIIString] :: ASCIIString -> String
-- | UnicodeString: generates a unicode String. The string will
-- not contain surrogate pairs.
newtype UnicodeString
UnicodeString :: String -> UnicodeString
[getUnicodeString] :: UnicodeString -> String
-- | PrintableString: generates a printable unicode String. The
-- string will not contain surrogate pairs.
newtype PrintableString
PrintableString :: String -> PrintableString
[getPrintableString] :: PrintableString -> String
-- | Generates an infinite list.
infiniteList :: Arbitrary a => Gen [a]
-- | Generates an ordered list.
orderedList :: (Ord a, Arbitrary a) => Gen [a]
-- | Generates a list of a given length.
vector :: Arbitrary a => Int -> Gen [a]
-- | A coarbitrary implementation for enums.
coarbitraryEnum :: Enum a => a -> Gen b -> Gen b
-- | coarbitrary helper for lazy people :-).
coarbitraryShow :: Show a => a -> Gen b -> Gen b
-- | A coarbitrary implementation for real numbers.
coarbitraryReal :: Real a => a -> Gen b -> Gen b
-- | A coarbitrary implementation for integral numbers.
coarbitraryIntegral :: Integral a => a -> Gen b -> Gen b
-- | Combine two generator perturbing functions, for example the results of
-- calls to variant or coarbitrary.
(><) :: () => (Gen a -> Gen a) -> (Gen a -> Gen a) -> Gen a -> Gen a
-- | Generic CoArbitrary implementation.
genericCoarbitrary :: (Generic a, GCoArbitrary (Rep a)) => a -> Gen b -> Gen b
-- | Shrink a real number, preferring numbers with shorter decimal
-- representations. See also shrinkRealFrac.
shrinkDecimal :: RealFrac a => a -> [a]
-- | Shrink a fraction, preferring numbers with smaller numerators or
-- denominators. See also shrinkDecimal.
shrinkRealFrac :: RealFrac a => a -> [a]
-- | Shrink an integral number.
shrinkIntegral :: Integral a => a -> [a]
-- | Non-overloaded version of shrinkMap.
shrinkMapBy :: () => (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b]
-- | 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
--
shrinkMap :: Arbitrary a => (a -> b) -> (b -> a) -> b -> [b]
-- | Returns no shrinking alternatives.
shrinkNothing :: () => a -> [a]
-- | Generates a printable Unicode character.
arbitraryPrintableChar :: Gen Char
-- | Generates a random ASCII character (0-127).
arbitraryASCIIChar :: Gen Char
-- | Generates any Unicode character (but not a surrogate)
arbitraryUnicodeChar :: Gen Char
-- | 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.
arbitrarySizedBoundedIntegral :: (Bounded a, Integral a) => Gen a
-- | Generates an element of a bounded enumeration.
arbitraryBoundedEnum :: (Bounded a, Enum a) => Gen a
-- | Generates an element of a bounded type. The element is chosen from the
-- entire range of the type.
arbitraryBoundedRandom :: (Bounded a, Random a) => Gen a
-- | Generates an integral number. The number is chosen uniformly from the
-- entire range of the type. You may want to use
-- arbitrarySizedBoundedIntegral instead.
arbitraryBoundedIntegral :: (Bounded a, Integral a) => Gen a
-- | Generates a fractional number. The number can be positive or negative
-- and its maximum absolute value depends on the size parameter.
arbitrarySizedFractional :: Fractional a => Gen a
-- | Generates a natural number. The number's maximum value depends on the
-- size parameter.
arbitrarySizedNatural :: Integral a => Gen a
-- | Generates an integral number. The number can be positive or negative
-- and its maximum absolute value depends on the size parameter.
arbitrarySizedIntegral :: Integral a => Gen a
-- | Apply a function of arity 4 to random arguments.
applyArbitrary4 :: (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => (a -> b -> c -> d -> r) -> Gen r
-- | Apply a ternary function to random arguments.
applyArbitrary3 :: (Arbitrary a, Arbitrary b, Arbitrary c) => (a -> b -> c -> r) -> Gen r
-- | Apply a binary function to random arguments.
applyArbitrary2 :: (Arbitrary a, Arbitrary b) => (a -> b -> r) -> Gen r
-- | Shrink a list of values given a shrinking function for individual
-- values.
shrinkList :: () => (a -> [a]) -> [a] -> [[a]]
-- | All immediate subterms of a term.
subterms :: (Generic a, GSubterms (Rep a) a) => a -> [a]
-- | Recursively shrink all immediate subterms.
recursivelyShrink :: (Generic a, RecursivelyShrink (Rep a)) => a -> [a]
-- | Shrink a term to any of its immediate subterms, and also recursively
-- shrink all subterms.
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)
-- | 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.
class Arbitrary a
-- | 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!
arbitrary :: Arbitrary a => Gen a
-- | 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:
--
--
-- - Shrink a term to any of its immediate subterms. You can use
-- subterms to do this.
-- - Recursively apply shrink to all immediate subterms. You can
-- use recursivelyShrink to do this.
-- - 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.
shrink :: Arbitrary a => a -> [a]
-- | Lifting of the Arbitrary class to unary type constructors.
class Arbitrary1 (f :: Type -> Type)
liftArbitrary :: Arbitrary1 f => Gen a -> Gen (f a)
liftShrink :: Arbitrary1 f => (a -> [a]) -> f a -> [f a]
-- | Lifting of the Arbitrary class to binary type constructors.
class Arbitrary2 (f :: Type -> Type -> Type)
liftArbitrary2 :: Arbitrary2 f => Gen a -> Gen b -> Gen (f a b)
liftShrink2 :: Arbitrary2 f => (a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
-- | 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).
class CoArbitrary a
-- | 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)
--
coarbitrary :: CoArbitrary a => a -> Gen b -> Gen b
-- | Generates an infinite list.
infiniteListOf :: () => Gen a -> Gen [a]
-- | Generates a list of the given length.
vectorOf :: () => Int -> Gen a -> Gen [a]
-- | Generates a non-empty list of random length. The maximum length
-- depends on the size parameter.
listOf1 :: () => Gen a -> Gen [a]
-- | Generates a list of random length. The maximum length depends on the
-- size parameter.
listOf :: () => Gen a -> Gen [a]
-- | Takes a list of elements of increasing size, and chooses among an
-- initial segment of the list. The size of this initial segment
-- increases with the size parameter. The input list must be non-empty.
growingElements :: () => [a] -> Gen a
-- | Generates a random permutation of the given list.
shuffle :: () => [a] -> Gen [a]
-- | Generates a random subsequence of the given list.
sublistOf :: () => [a] -> Gen [a]
-- | Generates one of the given values. The input list must be non-empty.
elements :: () => [a] -> Gen a
-- | Chooses one of the given generators, with a weighted random
-- distribution. The input list must be non-empty.
frequency :: () => [(Int, Gen a)] -> Gen a
-- | Randomly uses one of the given generators. The input list must be
-- non-empty.
oneof :: () => [Gen a] -> Gen a
-- | Tries to generate a value that satisfies a predicate. If it fails to
-- do so after enough attempts, returns Nothing.
suchThatMaybe :: () => Gen a -> (a -> Bool) -> Gen (Maybe a)
-- | Generates a value for which the given function returns a Just,
-- and then applies the function.
suchThatMap :: () => Gen a -> (a -> Maybe b) -> Gen b
-- | Generates a value that satisfies a predicate.
suchThat :: () => Gen a -> (a -> Bool) -> Gen a
-- | Generates some example values and prints them to stdout.
sample :: Show a => Gen a -> IO ()
-- | Generates some example values.
sample' :: () => Gen a -> IO [a]
-- | Run a generator. The size passed to the generator is always 30; if you
-- want another size then you should explicitly use resize.
generate :: () => Gen a -> IO a
-- | Generates a random element in the given inclusive range.
choose :: Random a => (a, a) -> Gen a
-- | Adjust the size parameter, by transforming it with the given function.
scale :: () => (Int -> Int) -> Gen a -> Gen a
-- | Overrides the size parameter. Returns a generator which uses the given
-- size instead of the runtime-size parameter.
resize :: () => Int -> Gen a -> Gen a
-- | 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.
getSize :: Gen Int
-- | 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.
sized :: () => (Int -> Gen a) -> Gen a
-- | Modifies a generator using an integer seed.
variant :: Integral n => n -> Gen a -> Gen a
-- | A generator for values of type a.
--
-- The third-party packages QuickCheck-GenT and
-- quickcheck-transformer provide monad transformer versions of
-- Gen.
data Gen a
-- | 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.
discard :: () => a
instance (GHC.Read.Read a, GHC.Read.Read b) => GHC.Read.Read (a Test.QuickCheck.Counterexamples.:&: b)
instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (a Test.QuickCheck.Counterexamples.:&: b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (a Test.QuickCheck.Counterexamples.:&: b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (a Test.QuickCheck.Counterexamples.:&: b)
instance GHC.Base.Functor Test.QuickCheck.Counterexamples.PropertyOf
instance Test.QuickCheck.Counterexamples.Testable Test.QuickCheck.Property.Discard
instance Test.QuickCheck.Counterexamples.Testable ()
instance Test.QuickCheck.Counterexamples.Testable prop => Test.QuickCheck.Counterexamples.Testable (GHC.Maybe.Maybe prop)
instance Test.QuickCheck.Counterexamples.Testable GHC.Types.Bool
instance Test.QuickCheck.Counterexamples.Testable Test.QuickCheck.Property.Property
instance Test.QuickCheck.Counterexamples.Testable prop => Test.QuickCheck.Counterexamples.Testable (Test.QuickCheck.Gen.Gen prop)
instance Test.QuickCheck.Counterexamples.Testable (Test.QuickCheck.Counterexamples.PropertyOf cex)
instance (GHC.Show.Show a, Test.QuickCheck.Arbitrary.Arbitrary a, Test.QuickCheck.Counterexamples.Testable b) => Test.QuickCheck.Counterexamples.Testable (a -> b)
instance Test.QuickCheck.Property.Testable (Test.QuickCheck.Counterexamples.PropertyOf cex)