Property and Testable types

The type of properties.

The class of properties, i.e., types which QuickCheck knows how to test. Typically a property will be a function returning Bool or Property.

If a property does no quantification, i.e. has no parameters and doesn't use forAll, it will only be tested once. This may not be what you want if your property is an IO Bool. You can change this behaviour using the again combinator.

If a property returns Discard, the current test case is discarded, the same as if a precondition was false.

Do I/O inside a property.

Do I/O inside a property.

Warning: any random values generated inside of the argument to ioProperty will not currently be shrunk. For best results, generate all random values before calling ioProperty.

Execute the IORose bits of a rose tree, returning a tree constructed by MkRose.

Apply a function to the outermost MkRose constructor of a rose tree. The function must be total!

Wrap a rose tree in an exception handler.

Wrap all the Results in a rose tree in exception handlers.

Different kinds of callbacks

The result of a single test.

Changes the maximum test case size for a property.

Shrinks the argument to a property if it fails. Shrinking is done automatically for most types. This function is only needed when you want to override the default behavior.

Disables shrinking for a property altogether.

Adds a callback

Adds the given string to the counterexample if the property fails.

Adds the given string to the counterexample if the property fails.

Performs an IO action after the last failure of a property.

Performs an IO action every time a property fails. Thus, if shrinking is done, this can be used to keep track of the failures along the way.

Prints out the generated testcase every time the property is tested. Only variables quantified over inside the verbose are printed.

Indicates that a property is supposed to fail. QuickCheck will report an error if it does not fail.

Modifies a property so that it only will be tested once. Opposite of again.

Modifies a property so that it will be tested repeatedly. Opposite of once.

Configures how many times a property will be tested.

For example,

quickCheck (withMaxSuccess 1000 p)

will test p up to 1000 times.

Attaches a label to a property. This is used for reporting test case distribution.

For example:

prop_reverse_reverse :: [Int] -> Property
prop_reverse_reverse xs =
  label ("length of input is " ++ show (length xs)) $
    reverse (reverse xs) === xs

>>> quickCheck prop_reverse_reverse
+++ OK, passed 100 tests:
7% length of input is 7
6% length of input is 3
5% length of input is 4
4% length of input is 6
...

Attaches a label to a property. This is used for reporting test case distribution.

collect x = label (show x)

For example:

prop_reverse_reverse :: [Int] -> Property
prop_reverse_reverse xs =
  collect (length xs) $
    reverse (reverse xs) === xs

>>> quickCheck prop_reverse_reverse
+++ OK, passed 100 tests:
7% 7
6% 3
5% 4
4% 6
...

Records how many test cases satisfy a given condition.

For example:

prop_sorted_sort :: [Int] -> Property
prop_sorted_sort xs =
  sorted xs ==>
  classify (length xs > 1) "non-trivial" $
  sort xs === xs

>>> quickCheck prop_sorted_sort
+++ OK, passed 100 tests (22% non-trivial).

Checks that at least the given proportion of successful test cases belong to the given class. Discarded tests (i.e. ones with a false precondition) do not affect coverage.

For example:

prop_sorted_sort :: [Int] -> Property
prop_sorted_sort xs =
  sorted xs ==>
  cover (length xs > 1) 50 "non-trivial" $
  sort xs === xs

>>> quickCheck prop_sorted_sort
*** Insufficient coverage after 100 tests (only 24% non-trivial, not 50%).

Implication for properties: The resulting property holds if the first argument is False (in which case the test case is discarded), or if the given property holds.

Considers a property failed if it does not complete within the given number of microseconds.

Explicit universal quantification: uses an explicitly given test case generator.

Like forAll, but tries to shrink the argument for failing test cases.

Nondeterministic choice: p1 .&. p2 picks randomly one of p1 and p2 to test. If you test the property 100 times it makes 100 random choices.

Conjunction: p1 .&&. p2 passes if both p1 and p2 pass.

Take the conjunction of several properties.

Disjunction: p1 .||. p2 passes unless p1 and p2 simultaneously fail.

Take the disjunction of several properties.

Like ==, but prints a counterexample when it fails.

Checks that a value is total, i.e., doesn't crash when evaluated.