QuickCheck-2.8: Automatic testing of Haskell programs

Safe Haskell | Trustworthy
Language | Haskell98

Test.QuickCheck.Modifiers

Contents

- Type-level modifiers for changing generator behavior

Description

Modifiers for test data.

These types do things such as restricting the kind of test data that can be generated. They can be pattern-matched on in properties as a stylistic alternative to using explicit quantification.

Examples:

    -- Functions cannot be shown (but see Test.QuickCheck.Function)
    prop_TakeDropWhile (Blind p) (xs :: [A]) =
      takeWhile p xs ++ dropWhile p xs == xs

    prop_TakeDrop (NonNegative n) (xs :: [A]) =
      take n xs ++ drop n xs == xs

    -- cycle does not work for empty lists
    prop_Cycle (NonNegative n) (NonEmpty (xs :: [A])) =
      take n (cycle xs) == take n (xs ++ cycle xs)

    -- Instead of forAll orderedList
    prop_Sort (Ordered (xs :: [OrdA])) =
      sort xs == xs

Synopsis

- newtype Blind a = Blind {
  - getBlind :: a
  }
- newtype Fixed a = Fixed {
  - getFixed :: a
  }
- newtype OrderedList a = Ordered {
  - getOrdered :: [a]
  }
- newtype NonEmptyList a = NonEmpty {
  - getNonEmpty :: [a]
  }
- newtype Positive a = Positive {
  - getPositive :: a
  }
- newtype NonZero a = NonZero {
  - getNonZero :: a
  }
- newtype NonNegative a = NonNegative {
  - getNonNegative :: a
  }
- newtype Large a = Large {
  - getLarge :: a
  }
- newtype Small a = Small {
  - getSmall :: a
  }
- data Smart a = Smart Int a
- newtype Shrink2 a = Shrink2 {
  - getShrink2 :: a
  }
- data Shrinking s a = Shrinking s a
- class ShrinkState s a where
  - shrinkInit :: a -> s
  - shrinkState :: a -> s -> [(a, s)]

## Type-level modifiers for changing generator behavior

newtype Blind a

`Blind x`: as x, but x does not have to be in the `Show` class.

Constructors

Blind |
Fields getBlind :: a

Instances

Functor Blind |
Enum a => Enum (Blind a) |
Eq a => Eq (Blind a) |
Integral a => Integral (Blind a) |
Num a => Num (Blind a) |
Ord a => Ord (Blind a) |
Real a => Real (Blind a) |
Show (Blind a) |
Arbitrary a => Arbitrary (Blind a) |

newtype Fixed a

`Fixed x`: as x, but will not be shrunk.

Constructors

Fixed |
Fields getFixed :: a

Instances

Functor Fixed |
Enum a => Enum (Fixed a) |
Eq a => Eq (Fixed a) |
Integral a => Integral (Fixed a) |
Num a => Num (Fixed a) |
Ord a => Ord (Fixed a) |
Read a => Read (Fixed a) |
Real a => Real (Fixed a) |
Show a => Show (Fixed a) |
Arbitrary a => Arbitrary (Fixed a) |

newtype OrderedList a

`Ordered xs`: guarantees that xs is ordered.

Constructors

Ordered |
Fields getOrdered :: [a]

Instances

Functor OrderedList |
Eq a => Eq (OrderedList a) |
Ord a => Ord (OrderedList a) |
Read a => Read (OrderedList a) |
Show a => Show (OrderedList a) |
(Ord a, Arbitrary a) => Arbitrary (OrderedList a) |

newtype NonEmptyList a

`NonEmpty xs`: guarantees that xs is non-empty.

Constructors

NonEmpty |
Fields getNonEmpty :: [a]

Instances

Functor NonEmptyList |
Eq a => Eq (NonEmptyList a) |
Ord a => Ord (NonEmptyList a) |
Read a => Read (NonEmptyList a) |
Show a => Show (NonEmptyList a) |
Arbitrary a => Arbitrary (NonEmptyList a) |

newtype Positive a

`Positive x`: guarantees that `x > 0`.

Constructors

Positive |
Fields getPositive :: a

Instances

Functor Positive |
Enum a => Enum (Positive a) |
Eq a => Eq (Positive a) |
Ord a => Ord (Positive a) |
Read a => Read (Positive a) |
Show a => Show (Positive a) |
(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a) |

newtype NonZero a

`NonZero x`: guarantees that `x /= 0`.

Constructors

NonZero |
Fields getNonZero :: a

Instances

Functor NonZero |
Enum a => Enum (NonZero a) |
Eq a => Eq (NonZero a) |
Ord a => Ord (NonZero a) |
Read a => Read (NonZero a) |
Show a => Show (NonZero a) |
(Num a, Ord a, Arbitrary a) => Arbitrary (NonZero a) |

newtype NonNegative a

`NonNegative x`: guarantees that `x >= 0`.

Constructors

NonNegative |
Fields getNonNegative :: a

Instances

Functor NonNegative |
Enum a => Enum (NonNegative a) |
Eq a => Eq (NonNegative a) |
Ord a => Ord (NonNegative a) |
Read a => Read (NonNegative a) |
Show a => Show (NonNegative a) |
(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a) |

newtype Large a

`Large x`: by default, QuickCheck generates `Int`s drawn from a small range. `Large Int` gives you values drawn from the entire range instead.

Constructors

Large |
Fields getLarge :: a

Instances

Functor Large |
Enum a => Enum (Large a) |
Eq a => Eq (Large a) |
Integral a => Integral (Large a) |
Num a => Num (Large a) |
Ord a => Ord (Large a) |
Read a => Read (Large a) |
Real a => Real (Large a) |
Show a => Show (Large a) |
(Integral a, Bounded a) => Arbitrary (Large a) |

newtype Small a

`Small x`: generates values of `x` drawn from a small range. The opposite of `Large`.

Constructors

Small |
Fields getSmall :: a

Instances

Functor Small |
Enum a => Enum (Small a) |
Eq a => Eq (Small a) |
Integral a => Integral (Small a) |
Num a => Num (Small a) |
Ord a => Ord (Small a) |
Read a => Read (Small a) |
Real a => Real (Small a) |
Show a => Show (Small a) |
Integral a => Arbitrary (Small a) |

data Smart a

`Smart _ x`: tries a different order when shrinking.

Constructors

Smart Int a |

Instances

Functor Smart |
Show a => Show (Smart a) |
Arbitrary a => Arbitrary (Smart a) |

newtype Shrink2 a

`Shrink2 x`: allows 2 shrinking steps at the same time when shrinking x

Constructors

Shrink2 |
Fields getShrink2 :: a

Instances

Functor Shrink2 |
Enum a => Enum (Shrink2 a) |
Eq a => Eq (Shrink2 a) |
Integral a => Integral (Shrink2 a) |
Num a => Num (Shrink2 a) |
Ord a => Ord (Shrink2 a) |
Read a => Read (Shrink2 a) |
Real a => Real (Shrink2 a) |
Show a => Show (Shrink2 a) |
Arbitrary a => Arbitrary (Shrink2 a) |

data Shrinking s a

`Shrinking _ x`: allows for maintaining a state during shrinking.

Constructors

Shrinking s a |

Instances

Functor (Shrinking s) |
Show a => Show (Shrinking s a) |
(Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a) |

class ShrinkState s a where

Methods

shrinkInit :: a -> s

shrinkState :: a -> s -> [(a, s)]