EqProp Bool #
Methods (=-=) :: Bool -> Bool -> Property #
EqProp Char #
Methods (=-=) :: Char -> Char -> Property #
EqProp Double #
Methods (=-=) :: Double -> Double -> Property #
EqProp Float #
Methods (=-=) :: Float -> Float -> Property #
EqProp Int #
Methods (=-=) :: Int -> Int -> Property #
EqProp () #
Methods (=-=) :: () -> () -> Property #
EqProp a => EqProp [a] #
Methods (=-=) :: [a] -> [a] -> Property #
EqProp a => EqProp (Maybe a) #
Methods (=-=) :: Maybe a -> Maybe a -> Property #
(Show a, Arbitrary a, EqProp b) => EqProp (a -> b) #
Methods (=-=) :: (a -> b) -> (a -> b) -> Property #
(EqProp a, EqProp b) => EqProp (Either a b) #
Methods (=-=) :: Either a b -> Either a b -> Property #
(EqProp a, EqProp b) => EqProp (a, b) #
Methods (=-=) :: (a, b) -> (a, b) -> Property #
(EqProp a, EqProp b, EqProp c) => EqProp (a, b, c) #
Methods (=-=) :: (a, b, c) -> (a, b, c) -> Property #
(EqProp a, EqProp b, EqProp c, EqProp d) => EqProp (a, b, c, d) #
Methods (=-=) :: (a, b, c, d) -> (a, b, c, d) -> Property #

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

For Eq types as EqProp types

type BinRel a = a -> a -> Bool #

reflexive :: (Arbitrary a, Show a) => BinRel a -> Property #

Reflexive property: a rel a

transitive :: (Arbitrary a, Show a) => BinRel a -> (a -> Gen a) -> Property #

Transitive property: a rel b && b rel c ==> a rel c. Generate a randomly, but use gen a to generate b and gen b to generate c. gen ought to satisfy rel fairly often.

symmetric :: (Arbitrary a, Show a) => BinRel a -> (a -> Gen a) -> Property #

Symmetric property: a rel b ==> b rel a. Generate a randomly, but use gen a to generate b. gen ought to satisfy rel fairly often.

antiSymmetric :: (Arbitrary a, Show a, Eq a) => BinRel a -> (a -> Gen a) -> Property #

Symmetric property: a rel b && b rel a ==> a == b. Generate a randomly, but use gen a to generate b. gen ought to satisfy both rel directions fairly often but not always.

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 #

Minimal complete definition

model

Methods

model :: a -> b #

Instances

Model Bool Bool #
Methods model :: Bool -> Bool #
Model Char Char #
Methods model :: Char -> Char #
Model Double Double #
Methods model :: Double -> Double #
Model Float Float #
Methods model :: Float -> Float #
Model Int Int #
Methods model :: Int -> Int #
Model String String #
Methods model :: String -> String #
(Model a b, Model a' b') => Model (a, a') (b, b') #
Methods 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.

Minimal complete definition

model1

Methods

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

Some handy testing types

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 infixr 1 #

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.

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

Orphan instances

Testable a => Testable [a] #
Methods property :: [a] -> Property #
(Testable a, Testable b) => Testable (a, b) #
Methods property :: (a, b) -> Property #