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

Type-level modifiers for changing generator behavior

newtype Blind a Source

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

Constructors

Blind
Fields getBlind :: a

newtype Fixed a Source

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

Constructors

Fixed
Fields getFixed :: a

Instances

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

newtype OrderedList a Source

Ordered xs: guarantees that xs is ordered.

Constructors

Ordered
Fields getOrdered :: [a]

Instances

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

newtype NonEmptyList a Source

NonEmpty xs: guarantees that xs is non-empty.

Constructors

NonEmpty
Fields getNonEmpty :: [a]

Instances

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

newtype Positive a Source

Positive x: guarantees that x > 0.

Constructors

Positive
Fields getPositive :: a

Instances

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

newtype NonZero a Source

NonZero x: guarantees that x /= 0.

Constructors

NonZero
Fields getNonZero :: a

Instances

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

newtype NonNegative a Source

NonNegative x: guarantees that x >= 0.

Constructors

NonNegative
Fields getNonNegative :: a

Instances

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

newtype Large a Source

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

Constructors

Large
Fields getLarge :: a

Instances

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

newtype Small a Source

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

Constructors

Small
Fields getSmall :: a

Instances

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

data Smart a Source

Smart _ x: tries a different order when shrinking.

Constructors

Smart Int a

Instances

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

newtype Shrink2 a Source

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

Constructors

Shrink2
Fields getShrink2 :: a

Instances

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

data Shrinking s a Source

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

Constructors

Shrinking s a

Instances

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

class ShrinkState s a where Source

Methods

shrinkInit :: a -> s Source

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

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