Test.QuickCheck.Checkers

Some QuickCheck helpers

Misc

type Test = (String, Property)

Named test

type TestBatch = (String, [Test])

Named batch of tests

unbatch :: TestBatch -> [Test]

Flatten a test batch for inclusion in another

checkBatch :: Config -> TestBatch -> IO ()

Run a batch of tests. See quickBatch and verboseBatch.

quickBatch :: TestBatch -> IO ()

Check a batch tersely.

verboseBatch :: TestBatch -> IO ()

Check a batch verbosely.

probablisticPureCheck :: Testable a => Config -> a -> Bool

type Unop a = a -> a

Unary function, handy for type annotations

type Binop a = a -> a -> a

Binary function, handy for type annotations

genR :: Random a => (a, a) -> Gen a

inverseL :: (EqProp b, Arbitrary b, Show b) => (a -> b) -> (b -> a) -> Property

f is a left inverse of g. See also inverse.

inverse :: (EqProp a, Arbitrary a, Show a, EqProp b, Arbitrary b, Show b) => (a -> b) -> (b -> a) -> Property

f is a left and right inverse of g. See also inverseL.

type FracT = Float

Token Fractional type for tests

type NumT = Int

Token Num type for tests

type OrdT = Char

Token Ord type for tests

type T = Char

Token uninteresting type for tests

Generalized equality

class EqProp a where

Types of values that can be tested for equality, perhaps through random sampling.

Methods

(=-=) :: a -> a -> Property

Instances

EqProp Bool

EqProp Char

EqProp Double

EqProp Int

EqProp a => EqProp [a]

EqProp a => EqProp (Maybe a)

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

(EqProp a, EqProp b) => EqProp (Either a b)

(EqProp a, EqProp b) => EqProp (a, b)

eq :: Eq a => a -> a -> Property

For Eq types as EqProp types

leftId :: (Show a, Arbitrary a, EqProp a) => (i -> a -> a) -> i -> Property

Has a given left identity, according to '(=-=)'

rightId :: (Show a, Arbitrary a, EqProp a) => (a -> i -> a) -> i -> Property

Has a given right identity, according to '(=-=)'

bothId :: (Show a, Arbitrary a, EqProp a) => (a -> a -> a) -> a -> Property

Has a given left and right identity, according to '(=-=)'

isAssoc :: (EqProp a, Show a, Arbitrary a) => (a -> a -> a) -> Property

Associative, according to '(=-=)'

isCommut :: (EqProp a, Show a, Arbitrary a) => (a -> a -> a) -> Property

Commutative, according to '(=-=)'

commutes :: EqProp z => (a -> a -> z) -> a -> a -> Property

Commutative, according to '(=-=)'

data MonoidD a

Explicit Monoid dictionary. Doesn't have to correspond to an actual Monoid instance, though see monoidD.

monoidD :: Monoid a => MonoidD a

Monoid dictionary built from the Monoid methods.

endoMonoidD :: MonoidD (a -> a)

Monoid dictionary for an unwrapped endomorphism. See also monoidD and Endo.

homomorphism :: (EqProp b, Show a, Arbitrary a) => MonoidD a -> MonoidD b -> (a -> b) -> [(String, Property)]

Homomorphism properties with respect to given monoid dictionaries. See also monoidMorphism.

idempotent :: (Show a, Arbitrary a, EqProp a) => (a -> a) -> Property

The unary function f is idempotent, i.e., f . f == f

idempotent2 :: (Show a, Arbitrary a, EqProp a) => (a -> a -> a) -> Property

A binary function op is idempotent, i.e., x op x == x, for all x

idemElem :: EqProp a => (a -> a -> a) -> a -> Property

A binary function op is has an idempotent element x, i.e., x op x == x

Model-based (semantics-based) testing

class Model a b | a -> b where

Methods

model :: a -> b

Instances

Model Bool Bool

Model Char Char

Model Double Double

Model Float Float

Model Int Int

Model String String

(Model a b, Model a' b') => Model (a, a') (b, b')

meq :: (Model a b, EqProp b) => a -> b -> Property

meq1 :: (Model a b, Model a1 b1, EqProp b) => (a1 -> a) -> (b1 -> b) -> a1 -> Property

meq2 :: (Model a b, Model a1 b1, Model a2 b2, EqProp b) => (a1 -> a2 -> a) -> (b1 -> b2 -> b) -> a1 -> a2 -> Property

meq3 :: (Model a b, Model a1 b1, Model a2 b2, Model a3 b3, EqProp b) => (a1 -> a2 -> a3 -> a) -> (b1 -> b2 -> b3 -> b) -> a1 -> a2 -> a3 -> Property

meq4 :: (Model a b, Model a1 b1, Model a2 b2, Model a3 b3, Model a4 b4, EqProp b) => (a1 -> a2 -> a3 -> a4 -> a) -> (b1 -> b2 -> b3 -> b4 -> b) -> a1 -> a2 -> a3 -> a4 -> Property

meq5 :: (Model a b, Model a1 b1, Model a2 b2, Model a3 b3, Model a4 b4, Model a5 b5, EqProp b) => (a1 -> a2 -> a3 -> a4 -> a5 -> a) -> (b1 -> b2 -> b3 -> b4 -> b5 -> b) -> a1 -> a2 -> a3 -> a4 -> a5 -> Property

eqModels :: (Model a b, EqProp b) => a -> a -> Property

class Model1 f g | f -> g where

Like Model but for unary type constructors.

Methods

model1 :: forall a. f a -> g a

Some handy testing types

type Positive a = NonZero (NonNegative a)

newtype NonZero a

Constructors

NonZero

Fields

unNonZero :: a

Instances

Enum a => Enum (NonZero a)

Eq a => Eq (NonZero a)

Integral a => Integral (NonZero a)

Num a => Num (NonZero a)

Ord a => Ord (NonZero a)

Read a => Read (NonZero a)

Real a => Real (NonZero a)

Show a => Show (NonZero a)

(Num a, Arbitrary a) => Arbitrary (NonZero a)

newtype NonNegative a

Constructors

NonNegative

Fields

unNonNegative :: a

Instances

Enum a => Enum (NonNegative a)

Eq a => Eq (NonNegative a)

Integral a => Integral (NonNegative a)

Num a => Num (NonNegative a)

Ord a => Ord (NonNegative a)

Read a => Read (NonNegative a)

Real a => Real (NonNegative a)

Show a => Show (NonNegative a)

(Num a, Arbitrary a) => Arbitrary (NonNegative a)

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

Generates a value that satisfies a predicate.

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

Tries to generate a value that satisfies a predicate.

arbs :: Arbitrary a => Int -> IO [a]

Generate n arbitrary values

gens :: Int -> Gen a -> IO [a]

Produce n values from a generator

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

Property conjunction

arbitrarySatisfying :: Arbitrary a => (a -> Bool) -> Gen a