Safe Haskell	Safe

Test.QuickCheck.Property

Contents

Property and Testable types

Description

Combinators for constructing properties.

Synopsis

Property and Testable types

newtype Property Source

The type of properties.

Constructors

MkProperty
Fields unProperty :: Gen Prop

Instances

Testable Property

class Testable prop whereSource

The class of things which can be tested, i.e. turned into a property.

Methods

property :: prop -> Property Source

Convert the thing to a property.

exhaustive :: prop -> Bool Source

If true, the property will only be tested once. However, if used inside a quantifier, it will be tested normally.

Instances

Testable Bool
Testable Result
Testable Prop
Testable Discard
Testable Property
Testable prop => Testable (Gen prop)
(Arbitrary a, Show a, Testable prop) => Testable (a -> prop)

data Discard Source

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

Constructors

Discard

Instances

Testable Discard

morallyDubiousIOProperty :: Testable prop => IO prop -> Property Source

Deprecated: Use ioProperty instead

Do I/O inside a property. This can obviously lead to unrepeatable testcases, so use with care.

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

Do I/O inside a property. This can obviously lead to unrepeatable testcases, so use with care.

For more advanced monadic testing you may want to look at Test.QuickCheck.Monadic.

Exception handling

protect :: (AnException -> a) -> IO a -> IO aSource

Type Prop

newtype Prop Source

Constructors

MkProp
Fields unProp :: Rose Result

Instances

Testable Prop

type Rose

data Rose a Source

Constructors

MkRose a [Rose a]
IORose (IO (Rose a))

Instances

Monad Rose
Functor Rose
Applicative Rose

ioRose :: IO (Rose Result) -> Rose Result Source

joinRose :: Rose (Rose a) -> Rose aSource

reduceRose :: Rose Result -> IO (Rose Result)Source

onRose :: (a -> [Rose a] -> Rose a) -> Rose a -> Rose aSource

protectRose :: IO (Rose Result) -> IO (Rose Result)Source

protectResults :: Rose Result -> Rose Result Source

Result type

data Callback Source

Different kinds of callbacks

Constructors

PostTest CallbackKind (State -> Result -> IO ())	Called just after a test
PostFinalFailure CallbackKind (State -> Result -> IO ())	Called with the final failing test-case

data CallbackKind Source

Constructors

Counterexample	Affected by the `verbose` combinator
NotCounterexample	Not affected by the `verbose` combinator

data Result Source

The result of a single test.

Constructors

MkResult

Fields

ok :: Maybe Bool: result of the test case; Nothing = discard
expect :: Bool: indicates what the expected result of the property is
reason :: String: a message indicating what went wrong
theException :: Maybe AnException: the exception thrown, if any
abort :: Bool: if True, the test should not be repeated
stamp :: [(String, Int)]: the collected values for this test case
callbacks :: [Callback]: the callbacks for this test case

Instances

Testable Result

result :: Result Source

exception :: String -> AnException -> Result Source

formatException :: String -> AnException -> String Source

protectResult :: IO Result -> IO Result Source

succeeded :: Result Source

failed :: Result Source

rejected :: Result Source

Lifting and mapping functions

liftBool :: Bool -> Result Source

mapResult :: Testable prop => (Result -> Result) -> prop -> Property Source

mapTotalResult :: Testable prop => (Result -> Result) -> prop -> Property Source

mapRoseResult :: Testable prop => (Rose Result -> Rose Result) -> prop -> Property Source

mapProp :: Testable prop => (Prop -> Prop) -> prop -> Property Source

Property combinators

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

Changes the maximum test case size for a property.

shrinking Source

Arguments

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

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

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

Disables shrinking for a property altogether.

callback :: Testable prop => Callback -> prop -> Property Source

Adds a callback

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

Adds the given string to the counterexample.

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

Deprecated: Use counterexample instead

Adds the given string to the counterexample.

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

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

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.

verbose :: Testable prop => prop -> Property Source

Prints out the generated testcase every time the property is tested. Only variables quantified over inside the verbose are printed.

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

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

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

Modifies a property so that it only will be tested once.

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

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

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

Labels a property with a value:

 collect x = label (show x)

classify Source

Arguments

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

Conditionally labels test case.

cover Source

Arguments

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

Checks that at least the given proportion of the test cases belong to the given class.

(==>) :: Testable prop => Bool -> prop -> Property 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.

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

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

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

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

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.

(.&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property 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.

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

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

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

Take the conjunction of several properties.

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

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

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

Take the disjunction of several properties.

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

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