Data.GenValidity

GenValidity exists to make tests involving Validity types easier and speed up the generation of data for them.

Let's use the example from Data.Validity again: A datatype that represents primes. To implement tests for this datatype, we would have to be able to generate both primes and non-primes. We could do this with (Prime $ arbitrary) suchThat isValid but this is tedious and inefficient.

The GenValid type class allows you to specify how to (efficiently) generate valid data of the given type to allow for easier and quicker testing. Just instantiating GenUnchecked already gives you access to a default instance of GenValid and GenInvalid but writing custom implementations of these functions may speed up the generation of data.

For example, to generate primes, we don't have to consider even numbers other than 2. A more efficient implementation could then look as follows:

instance GenUnchecked Prime where
    genUnchecked = Prime <$> arbitrary

instance GenValid Prime where
    genValid = Prime <$>
       (oneof
         [ pure 2
         , ((\y -> 2 * abs y + 1) <$> arbitrary) `suchThat` isPrime)
         ])

Typical examples of tests involving validity could look as follows:

it "succeeds when given valid input" $ do
    forAllValid $ \input ->
        myFunction input `shouldSatisfy` isRight

it "produces valid output when it succeeds" $ do
    forAllUnchecked $ \input ->
        case myFunction input of
            Nothing -> return () -- Can happen
            Just output -> output `shouldSatisfy` isValid

Documentation

module Data.Validity

class GenUnchecked a where

A class of types for which truly arbitrary values can be generated.

Automatic instances with Generic

An instance of this class can be made automatically if the type in question has a Generic instance. This instance will try to use genUnchecked to generate all structural sub-parts of the value that is being generated.

Example:

{-# LANGUAGE DeriveGeneric #-}

data MyType = MyType Double String
    deriving (Show, Eq, Generic)

instance GenUnchecked MyType

generates something like:

instance GenUnchecked MyType where
    genUnchecked = MyType <$> genUnchecked <*> genUnchecked

Methods

genUnchecked :: Gen a

genUnchecked :: (Generic a, GGenUnchecked (Rep a)) => Gen a

shrinkUnchecked :: a -> [a]

shrinkUnchecked :: (Generic a, GUncheckedRecursivelyShrink (Rep a), GUncheckedSubterms (Rep a) a) => a -> [a]

Instances

GenUnchecked Bool

Methods

genUnchecked :: Gen Bool

shrinkUnchecked :: Bool -> [Bool]

GenUnchecked Char

Methods

genUnchecked :: Gen Char

shrinkUnchecked :: Char -> [Char]

GenUnchecked Double

Methods

genUnchecked :: Gen Double

shrinkUnchecked :: Double -> [Double]

GenUnchecked Float

Methods

genUnchecked :: Gen Float

shrinkUnchecked :: Float -> [Float]

GenUnchecked Int

Methods

genUnchecked :: Gen Int

shrinkUnchecked :: Int -> [Int]

GenUnchecked Int8

Methods

genUnchecked :: Gen Int8

shrinkUnchecked :: Int8 -> [Int8]

GenUnchecked Int16

Methods

genUnchecked :: Gen Int16

shrinkUnchecked :: Int16 -> [Int16]

GenUnchecked Int32

Methods

genUnchecked :: Gen Int32

shrinkUnchecked :: Int32 -> [Int32]

GenUnchecked Int64

Methods

genUnchecked :: Gen Int64

shrinkUnchecked :: Int64 -> [Int64]

GenUnchecked Integer

Methods

genUnchecked :: Gen Integer

shrinkUnchecked :: Integer -> [Integer]

GenUnchecked Ordering

Methods

genUnchecked :: Gen Ordering

shrinkUnchecked :: Ordering -> [Ordering]

GenUnchecked Word

Methods

genUnchecked :: Gen Word

shrinkUnchecked :: Word -> [Word]

GenUnchecked Word8

Methods

genUnchecked :: Gen Word8

shrinkUnchecked :: Word8 -> [Word8]

GenUnchecked Word16

Methods

genUnchecked :: Gen Word16

shrinkUnchecked :: Word16 -> [Word16]

GenUnchecked Word32

Methods

genUnchecked :: Gen Word32

shrinkUnchecked :: Word32 -> [Word32]

GenUnchecked Word64

Methods

genUnchecked :: Gen Word64

shrinkUnchecked :: Word64 -> [Word64]

GenUnchecked ()

Methods

genUnchecked :: Gen ()

shrinkUnchecked :: () -> [()]

GenUnchecked a => GenUnchecked [a]

Methods

genUnchecked :: Gen [a]

shrinkUnchecked :: [a] -> [[a]]

GenUnchecked a => GenUnchecked (Maybe a)

Methods

genUnchecked :: Gen (Maybe a)

shrinkUnchecked :: Maybe a -> [Maybe a]

(Integral a, GenUnchecked a) => GenUnchecked (Ratio a)

Methods

genUnchecked :: Gen (Ratio a)

shrinkUnchecked :: Ratio a -> [Ratio a]

HasResolution a => GenUnchecked (Fixed a)

Methods

genUnchecked :: Gen (Fixed a)

shrinkUnchecked :: Fixed a -> [Fixed a]

GenUnchecked a => GenUnchecked (NonEmpty a)

Methods

genUnchecked :: Gen (NonEmpty a)

shrinkUnchecked :: NonEmpty a -> [NonEmpty a]

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

Methods

genUnchecked :: Gen (Either a b)

shrinkUnchecked :: Either a b -> [Either a b]

(GenUnchecked a, GenUnchecked b) => GenUnchecked (a, b)

Methods

genUnchecked :: Gen (a, b)

shrinkUnchecked :: (a, b) -> [(a, b)]

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

Methods

genUnchecked :: Gen (a, b, c)

shrinkUnchecked :: (a, b, c) -> [(a, b, c)]

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

Methods

genUnchecked :: Gen (a, b, c, d)

shrinkUnchecked :: (a, b, c, d) -> [(a, b, c, d)]

class (Validity a, GenUnchecked a) => GenValid a where

A class of types for which valid values can be generated.

If you also write Arbitrary instances for GenValid types, it may be best to simply write arbitrary = genValid.

Methods

genValid :: Gen a

shrinkValid :: a -> [a]

Instances

GenValid Bool

Methods

genValid :: Gen Bool

shrinkValid :: Bool -> [Bool]

GenValid Char

Methods

genValid :: Gen Char

shrinkValid :: Char -> [Char]

GenValid Double

Methods

genValid :: Gen Double

shrinkValid :: Double -> [Double]

GenValid Float

Methods

genValid :: Gen Float

shrinkValid :: Float -> [Float]

GenValid Int

Methods

genValid :: Gen Int

shrinkValid :: Int -> [Int]

GenValid Int8

Methods

genValid :: Gen Int8

shrinkValid :: Int8 -> [Int8]

GenValid Int16

Methods

genValid :: Gen Int16

shrinkValid :: Int16 -> [Int16]

GenValid Int32

Methods

genValid :: Gen Int32

shrinkValid :: Int32 -> [Int32]

GenValid Int64

Methods

genValid :: Gen Int64

shrinkValid :: Int64 -> [Int64]

GenValid Integer

Methods

genValid :: Gen Integer

shrinkValid :: Integer -> [Integer]

GenValid Ordering

Methods

genValid :: Gen Ordering

shrinkValid :: Ordering -> [Ordering]

GenValid Word

Methods

genValid :: Gen Word

shrinkValid :: Word -> [Word]

GenValid Word8

Methods

genValid :: Gen Word8

shrinkValid :: Word8 -> [Word8]

GenValid Word16

Methods

genValid :: Gen Word16

shrinkValid :: Word16 -> [Word16]

GenValid Word32

Methods

genValid :: Gen Word32

shrinkValid :: Word32 -> [Word32]

GenValid Word64

Methods

genValid :: Gen Word64

shrinkValid :: Word64 -> [Word64]

GenValid ()

Methods

genValid :: Gen ()

shrinkValid :: () -> [()]

GenValid a => GenValid [a]

If we can generate values of a certain type, we can also generate lists of them.

Methods

genValid :: Gen [a]

shrinkValid :: [a] -> [[a]]

GenValid a => GenValid (Maybe a)

Methods

genValid :: Gen (Maybe a)

shrinkValid :: Maybe a -> [Maybe a]

(Integral a, Num a, Ord a, GenValid a) => GenValid (Ratio a)

Methods

genValid :: Gen (Ratio a)

shrinkValid :: Ratio a -> [Ratio a]

HasResolution a => GenValid (Fixed a)

Methods

genValid :: Gen (Fixed a)

shrinkValid :: Fixed a -> [Fixed a]

GenValid a => GenValid (NonEmpty a)

Methods

genValid :: Gen (NonEmpty a)

shrinkValid :: NonEmpty a -> [NonEmpty a]

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

Methods

genValid :: Gen (Either a b)

shrinkValid :: Either a b -> [Either a b]

(GenValid a, GenValid b) => GenValid (a, b)

Methods

genValid :: Gen (a, b)

shrinkValid :: (a, b) -> [(a, b)]

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

Methods

genValid :: Gen (a, b, c)

shrinkValid :: (a, b, c) -> [(a, b, c)]

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

Methods

genValid :: Gen (a, b, c, d)

shrinkValid :: (a, b, c, d) -> [(a, b, c, d)]

class (Validity a, GenUnchecked a) => GenInvalid a where

A class of types for which invalid values can be generated.

Methods

genInvalid :: Gen a

shrinkInvalid :: a -> [a]

Instances

GenInvalid Double

Either NaN or Infinity.

Methods

genInvalid :: Gen Double

shrinkInvalid :: Double -> [Double]

GenInvalid Float

Either NaN or Infinity.

Methods

genInvalid :: Gen Float

shrinkInvalid :: Float -> [Float]

GenInvalid a => GenInvalid [a]

This instance ensures that the generated list contains at least one element that satisfies isInvalid. The rest is unchecked.

Methods

genInvalid :: Gen [a]

shrinkInvalid :: [a] -> [[a]]

GenInvalid a => GenInvalid (Maybe a)

Methods

genInvalid :: Gen (Maybe a)

shrinkInvalid :: Maybe a -> [Maybe a]

(Integral a, Num a, Ord a, GenValid a) => GenInvalid (Ratio a)

Methods

genInvalid :: Gen (Ratio a)

shrinkInvalid :: Ratio a -> [Ratio a]

GenInvalid a => GenInvalid (NonEmpty a)

Methods

genInvalid :: Gen (NonEmpty a)

shrinkInvalid :: NonEmpty a -> [NonEmpty a]

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

This instance ensures that the generated tupse contains at least one invalid element. The other element is unchecked.

Methods

genInvalid :: Gen (Either a b)

shrinkInvalid :: Either a b -> [Either a b]

(GenInvalid a, GenInvalid b) => GenInvalid (a, b)

Methods

genInvalid :: Gen (a, b)

shrinkInvalid :: (a, b) -> [(a, b)]

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

This instance ensures that the generated triple contains at least one invalid element. The other two are unchecked.

Methods

genInvalid :: Gen (a, b, c)

shrinkInvalid :: (a, b, c) -> [(a, b, c)]

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

This instance ensures that the generated triple contains at least one invalid element. The other two are unchecked.

Methods

genInvalid :: Gen (a, b, c, d)

shrinkInvalid :: (a, b, c, d) -> [(a, b, c, d)]

shrinkT2 :: (a -> [a]) -> (a, a) -> [(a, a)]

shrinkT3 :: (a -> [a]) -> (a, a, a) -> [(a, a, a)]

upTo :: Int -> Gen Int

upTo generates an integer between 0 (inclusive) and n.

genSplit :: Int -> Gen (Int, Int)

'genSplit a' generates a tuple '(b, c)' such that 'b + c' equals a.

genSplit3 :: Int -> Gen (Int, Int, Int)

'genSplit3 a' generates a triple '(b, c, d)' such that 'b + c + d' equals a.

genSplit4 :: Int -> Gen (Int, Int, Int, Int)

'genSplit4 a' generates a quadruple '(b, c, d, e)' such that 'b + c + d + e' equals a.

arbPartition :: Int -> Gen [Int]

'arbPartition n' generates a list ls such that 'sum ls' equals n.

genListOf :: Gen a -> Gen [a]

A version of listOf that takes size into account more accurately.

class GGenUnchecked f where

Minimal complete definition

gGenUnchecked

Methods

gGenUnchecked :: Gen (f a)

Instances

GGenUnchecked (U1 *)

Methods

gGenUnchecked :: Gen (U1 * a)

GenUnchecked a => GGenUnchecked (K1 * i a)

Methods

gGenUnchecked :: Gen (K1 * i a a)

(GGenUnchecked a, GGenUnchecked b) => GGenUnchecked ((:+:) * a b)

Methods

gGenUnchecked :: Gen ((* :+: a) b a)

(GGenUnchecked a, GGenUnchecked b) => GGenUnchecked ((:*:) * a b)

Methods

gGenUnchecked :: Gen ((* :*: a) b a)

GGenUnchecked a => GGenUnchecked (M1 * i c a)

Methods

gGenUnchecked :: Gen (M1 * i c a a)

gShrinkUnchecked :: (Generic a, GUncheckedRecursivelyShrink (Rep a), GUncheckedSubterms (Rep a) a) => a -> [a]

Shrink a term to any of its immediate subterms, and also recursively shrink all subterms.

uncheckedRecursivelyShrink :: (Generic a, GUncheckedRecursivelyShrink (Rep a)) => a -> [a]

Recursively shrink all immediate uncheckedSubterms.

class GUncheckedRecursivelyShrink f where

Minimal complete definition

gUncheckedRecursivelyShrink

Methods

gUncheckedRecursivelyShrink :: f a -> [f a]

Instances

GUncheckedRecursivelyShrink (V1 *)

Methods

gUncheckedRecursivelyShrink :: V1 * a -> [V1 * a]

GUncheckedRecursivelyShrink (U1 *)

Methods

gUncheckedRecursivelyShrink :: U1 * a -> [U1 * a]

GenUnchecked a => GUncheckedRecursivelyShrink (K1 * i a)

Methods

gUncheckedRecursivelyShrink :: K1 * i a a -> [K1 * i a a]

(GUncheckedRecursivelyShrink f, GUncheckedRecursivelyShrink g) => GUncheckedRecursivelyShrink ((:+:) * f g)

Methods

gUncheckedRecursivelyShrink :: (* :+: f) g a -> [(* :+: f) g a]

(GUncheckedRecursivelyShrink f, GUncheckedRecursivelyShrink g) => GUncheckedRecursivelyShrink ((:*:) * f g)

Methods

gUncheckedRecursivelyShrink :: (* :*: f) g a -> [(* :*: f) g a]

GUncheckedRecursivelyShrink f => GUncheckedRecursivelyShrink (M1 * i c f)

Methods

gUncheckedRecursivelyShrink :: M1 * i c f a -> [M1 * i c f a]

uncheckedSubterms :: (Generic a, GUncheckedSubterms (Rep a) a) => a -> [a]

All immediate uncheckedSubterms of a term.

class GUncheckedSubterms f a where

Minimal complete definition

gUncheckedSubterms

Methods

gUncheckedSubterms :: f a -> [a]

Instances

GUncheckedSubterms (V1 *) a

Methods

gUncheckedSubterms :: V1 * a -> [a]

GUncheckedSubterms (U1 *) a

Methods

gUncheckedSubterms :: U1 * a -> [a]

GUncheckedSubterms (K1 * i a) b

Methods

gUncheckedSubterms :: K1 * i a b -> [b]

(GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubterms ((:+:) * f g) a

Methods

gUncheckedSubterms :: (* :+: f) g a -> [a]

(GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubterms ((:*:) * f g) a

Methods

gUncheckedSubterms :: (* :*: f) g a -> [a]

GUncheckedSubterms f a => GUncheckedSubterms (M1 * i c f) a

Methods

gUncheckedSubterms :: M1 * i c f a -> [a]

class GUncheckedSubtermsIncl f a where

Minimal complete definition

gUncheckedSubtermsIncl

Methods

gUncheckedSubtermsIncl :: f a -> [a]

Instances

GUncheckedSubtermsIncl (V1 *) a

Methods

gUncheckedSubtermsIncl :: V1 * a -> [a]

GUncheckedSubtermsIncl (U1 *) a

Methods

gUncheckedSubtermsIncl :: U1 * a -> [a]

GUncheckedSubtermsIncl (K1 * i a) b

Methods

gUncheckedSubtermsIncl :: K1 * i a b -> [b]

GUncheckedSubtermsIncl (K1 * i a) a

Methods

gUncheckedSubtermsIncl :: K1 * i a a -> [a]

(GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubtermsIncl ((:+:) * f g) a

Methods

gUncheckedSubtermsIncl :: (* :+: f) g a -> [a]

(GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubtermsIncl ((:*:) * f g) a

Methods

gUncheckedSubtermsIncl :: (* :*: f) g a -> [a]

GUncheckedSubtermsIncl f a => GUncheckedSubtermsIncl (M1 * i c f) a

Methods

gUncheckedSubtermsIncl :: M1 * i c f a -> [a]