Safe Haskell | None |
---|

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

- newtype Blind a = Blind a
- newtype Fixed a = Fixed a
- newtype OrderedList a = Ordered [a]
- newtype NonEmptyList a = NonEmpty [a]
- newtype Positive a = Positive a
- newtype NonZero a = NonZero a
- newtype NonNegative a = NonNegative a
- data Smart a = Smart Int a
- newtype Shrink2 a = Shrink2 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

`Fixed x`

: as x, but will not be shrunk.

Fixed a |

newtype OrderedList a Source

`Ordered xs`

: guarantees that xs is ordered.

Ordered [a] |

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 Source

`NonEmpty xs`

: guarantees that xs is non-empty.

NonEmpty [a] |

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) |

`Positive x`

: guarantees that `x > 0`

.

Positive a |

`NonZero x`

: guarantees that `x /= 0`

.

NonZero a |

newtype NonNegative a Source

`NonNegative x`

: guarantees that `x >= 0`

.

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, Ord a, Arbitrary a) => Arbitrary (NonNegative a) |

`Smart _ x`

: tries a different order when shrinking.

`Shrink2 x`

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

Shrink2 a |

`Shrinking _ x`

: allows for maintaining a state during shrinking.

Shrinking s a |

class ShrinkState s a whereSource

shrinkInit :: a -> sSource

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