Test.QuickCheck.Counterexamples

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]

Here is how this module's API differs from normal QuickCheck, in more detail:

• The Testable class now has an associated type Counterexample which describes the counterexample. Property is now a synonym for PropertyOf (), where PropertyOf cex represents a property with an associated counterexample cex. The QuickCheck property combinators preserve the counterexample, by returning PropertyOf instead of Property.
• quickCheck and related functions return a Counterexample prop.
• Finally, there are a couple of new combinators, documented below.

The PropertyOf type and Testable typeclass

newtype PropertyOf cex

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.

Constructors

MkProperty

Fields

• unProperty :: (cex -> IO ()) -> Property

  Implementation note: the property receives a callback to which it should pass the counterexample after shrinking.

Instances

Functor PropertyOf

Methods

fmap :: (a -> b) -> PropertyOf a -> PropertyOf b

(<$) :: a -> PropertyOf b -> PropertyOf a

Testable (PropertyOf cex)

Methods

property :: PropertyOf cex -> Property

Testable (PropertyOf cex)

Associated Types

type Counterexample (PropertyOf cex) :: *

Methods

property :: PropertyOf cex -> PropertyFrom (PropertyOf cex)

type Counterexample (PropertyOf cex)

type Counterexample (PropertyOf cex) = cex

type Property = PropertyOf ()

A property which doesn't produce a counterexample.

type PropertyFrom prop = PropertyOf (Counterexample prop)

A type synonym for the property which comes from a particular Testable instance.

class Testable prop => Testable prop where

The class of properties, i.e. types which QuickCheck knows how to test.

Minimal complete definition

property

Associated Types

type Counterexample prop

The type of counterexamples to the property.

Methods

property :: prop -> PropertyFrom prop

Convert the property to a PropertyOf.

Instances

Testable Bool

Associated Types

type Counterexample Bool :: *

Methods

property :: Bool -> PropertyFrom Bool

Testable Property

Associated Types

type Counterexample Property :: *

Methods

property :: Property -> PropertyFrom Property

Testable Discard

Associated Types

type Counterexample Discard :: *

Methods

property :: Discard -> PropertyFrom Discard

Testable prop => Testable (Gen prop)

Associated Types

type Counterexample (Gen prop) :: *

Methods

property :: Gen prop -> PropertyFrom (Gen prop)

Testable (PropertyOf cex)

Associated Types

type Counterexample (PropertyOf cex) :: *

Methods

property :: PropertyOf cex -> PropertyFrom (PropertyOf cex)

(Show a, Arbitrary a, Testable b) => Testable (a -> b)

Associated Types

type Counterexample (a -> b) :: *

Methods

property :: (a -> b) -> PropertyFrom (a -> b)

New functionality which is not in QuickCheck

data a :&: b infixr 6

A type of pairs. Used in counterexamples.

Constructors

a :&: b infixr 6

Instances

(Eq b, Eq a) => Eq ((:&:) a b)

Methods

(==) :: (a :&: b) -> (a :&: b) -> Bool

(/=) :: (a :&: b) -> (a :&: b) -> Bool

(Ord b, Ord a) => Ord ((:&:) a b)

Methods

compare :: (a :&: b) -> (a :&: b) -> Ordering

(<) :: (a :&: b) -> (a :&: b) -> Bool

(<=) :: (a :&: b) -> (a :&: b) -> Bool

(>) :: (a :&: b) -> (a :&: b) -> Bool

(>=) :: (a :&: b) -> (a :&: b) -> Bool

max :: (a :&: b) -> (a :&: b) -> a :&: b

min :: (a :&: b) -> (a :&: b) -> a :&: b

(Read b, Read a) => Read ((:&:) a b)

Methods

readsPrec :: Int -> ReadS (a :&: b)

readList :: ReadS [a :&: b]

readPrec :: ReadPrec (a :&: b)

readListPrec :: ReadPrec [a :&: b]

(Show b, Show a) => Show ((:&:) a b)

Methods

showsPrec :: Int -> (a :&: b) -> ShowS

show :: (a :&: b) -> String

showList :: [a :&: b] -> ShowS

typedCounterexample :: Testable prop => a -> prop -> PropertyOf (a :&: Counterexample prop)

Add a value to the counterexample.

onProperty :: Testable prop => (Property -> Property) -> prop -> PropertyFrom prop

Lift an ordinary QuickCheck property combinator to one with counterexamples.

The standard QuickCheck combinators, updated to return counterexamples

quickCheck :: Testable prop => prop -> IO (Maybe (Counterexample prop))

See quickCheck in Test.QuickCheck.

quickCheckWith :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop))

See quickCheckWith in Test.QuickCheck.

quickCheckResult :: Testable prop => prop -> IO (Maybe (Counterexample prop), Result)

See quickCheckResult in Test.QuickCheck.

quickCheckWithResult :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop), Result)

See quickCheckWithResult in Test.QuickCheck.

verboseCheck :: Testable prop => prop -> IO (Maybe (Counterexample prop))

See verboseCheck in Test.QuickCheck.

verboseCheckWith :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop))

See verboseCheckWith in Test.QuickCheck.

verboseCheckResult :: Testable prop => prop -> IO (Maybe (Counterexample prop), Result)

See verboseCheckResult in Test.QuickCheck.

verboseCheckWithResult :: Testable prop => Args -> prop -> IO (Maybe (Counterexample prop), Result)

See verboseCheckWithResult in Test.QuickCheck.

polyQuickCheck :: Name -> ExpQ

See polyQuickCheck in Test.QuickCheck.

polyVerboseCheck :: Name -> ExpQ

See polyVerboseCheck in Test.QuickCheck.

forAll :: (Testable prop, Show a) => Gen a -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)

See forAll in Test.QuickCheck.

forAllShrink :: (Testable prop, Show a) => Gen a -> (a -> [a]) -> (a -> prop) -> PropertyOf (a :&: Counterexample prop)

See forAllShrink in Test.QuickCheck.

shrinking :: Testable prop => (a -> [a]) -> a -> (a -> prop) -> PropertyFrom prop

See shrinking 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.

ioProperty :: Testable prop => IO prop -> PropertyFrom prop

See ioProperty in Test.QuickCheck.

verbose :: Testable prop => prop -> PropertyFrom prop

See verbose in Test.QuickCheck.

once :: Testable prop => prop -> PropertyFrom prop

See once in Test.QuickCheck.

again :: Testable prop => prop -> PropertyFrom prop

See again in Test.QuickCheck.

within :: Testable prop => Int -> prop -> PropertyFrom prop

See within in Test.QuickCheck.

noShrinking :: Testable prop => prop -> PropertyFrom prop

See noShrinking in Test.QuickCheck.

counterexample :: Testable prop => String -> prop -> PropertyFrom prop

See counterexample in Test.QuickCheck.

whenFail :: Testable prop => IO () -> prop -> PropertyFrom prop

See whenFail in Test.QuickCheck.

whenFail' :: Testable prop => IO () -> prop -> PropertyFrom prop

See whenFail' in Test.QuickCheck.

expectFailure :: Testable prop => prop -> PropertyFrom prop

See expectFailure in Test.QuickCheck.

label :: Testable prop => String -> prop -> PropertyFrom prop

See label in Test.QuickCheck.

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

See collect in Test.QuickCheck.

classify :: Testable prop => Bool -> String -> prop -> PropertyFrom prop

See classify in Test.QuickCheck.

cover :: Testable prop => Bool -> Int -> String -> prop -> PropertyFrom prop

See cover in Test.QuickCheck.

mapSize :: Testable prop => (Int -> Int) -> prop -> PropertyFrom prop

See mapSize in Test.QuickCheck.

module Test.QuickCheck