Fake.Cover

Generate fake values with full constructor coverage

The idea behind Fake.Cover is that although exhaustive testing is highly exponential, you can cover a large portion of the likely problem cases by exercising all the constructors of a data type and associated fields. This approach only requires a sub-exponential number of cases--far fewer than what you need for the exhaustive approach. The number of test cases needed to ensure that you have full coverage of all the constructors is given by the following relations for product and sum types:

numCases (a, b) = max (numCases a) (numCases b)

numCases (Either a b) = numCases a + numCases b

See the test suite for examples of how many values are generated for different data types.

Documentation

gcover :: (Generic a, GCover ga, ga ~ Rep a) => Coverage a

A generic function that gives you full constructor coverage for a data type. Using this function as the Cover instance for a data type avoids the need to explicitly enumerate values that include coverage of all constructors.

newtype Coverage a

Coverage is a list of values, implemented here with a newtype around a list of fake value generators. It's [FGen a] instead of FGen [a] because we don't want to have to evaluate the FGen monad to work with coverage lists.

Constructors

Coverage

Fields

• unCoverage :: [FGen a]

Instances

Functor Coverage

Defined in Fake.Cover

Methods

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

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

Applicative Coverage

Defined in Fake.Cover

Methods

pure :: a -> Coverage a

(<*>) :: Coverage (a -> b) -> Coverage a -> Coverage b

liftA2 :: (a -> b -> c) -> Coverage a -> Coverage b -> Coverage c

(*>) :: Coverage a -> Coverage b -> Coverage b

(<*) :: Coverage a -> Coverage b -> Coverage a

Alternative Coverage

Defined in Fake.Cover

Methods

empty :: Coverage a

(<|>) :: Coverage a -> Coverage a -> Coverage a

some :: Coverage a -> Coverage [a]

many :: Coverage a -> Coverage [a]

class Cover a where

A type class that generates a list of values giving full construcor coverage for data types. You can write your own instances by hand or you can use the default instance which calls gcover provided your data type has a Generic instance.

Minimal complete definition

Nothing

Methods

cover :: Coverage a

default cover :: (Generic a, GCover ga, ga ~ Rep a) => Coverage a

Instances

Cover ()

Defined in Fake.Cover

Methods

cover :: Coverage ()

Cover a => Cover (Maybe a)

Defined in Fake.Cover

Methods

cover :: Coverage (Maybe a)

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

Defined in Fake.Cover

Methods

cover :: Coverage (Either a b)

(Cover a, Cover b) => Cover (a, b)

Defined in Fake.Cover

Methods

cover :: Coverage (a, b)

(Cover a, Cover b, Cover c) => Cover (a, b, c)

Defined in Fake.Cover

Methods

cover :: Coverage (a, b, c)

(Cover a, Cover b, Cover c, Cover d) => Cover (a, b, c, d)

Defined in Fake.Cover

Methods

cover :: Coverage (a, b, c, d)

(Cover a, Cover b, Cover c, Cover d, Cover e) => Cover (a, b, c, d, e)

Defined in Fake.Cover

Methods

cover :: Coverage (a, b, c, d, e)

(Cover a, Cover b, Cover c, Cover d, Cover e, Cover f) => Cover (a, b, c, d, e, f)

Defined in Fake.Cover

Methods

cover :: Coverage (a, b, c, d, e, f)

(Cover a, Cover b, Cover c, Cover d, Cover e, Cover f, Cover g) => Cover (a, b, c, d, e, f, g)

Defined in Fake.Cover

Methods

cover :: Coverage (a, b, c, d, e, f, g)

bindCover :: Coverage a -> (a -> FGen b) -> Coverage b

In some situations you don't have the ability to modify a data structure and need to define different Cover instances for different fields that have the same type. In these situations, instead of implementing the gcover logic by hand, you could alternatively use gcover to generate stock coverage values and then go back and replace the necessary fields with more appropriate generators. This bind-like operation provides an easy way to do that.

(&>>=) :: Coverage a -> (a -> FGen b) -> Coverage b infixl 1

Convenience infix operator for bindCover.

instance Cover Foo where
  cover = gcover
    &>>= fooField %%~ (_ -> fakeFooField)