Properties are expressed as F# function definitions or C# lambdas or methods. Properties are universally quantified over their parameters, so

let revRevIsOrig (xs:list<int>) = List.rev(List.rev xs) = xs
public static bool RevRevIsOriginal(int[] ts) {
    return ts.Reverse().Reverse().SequenceEqual(ts);

means that the equality holds for all lists xs.

Properties must not have generic types - because there can be so many different kinds of constraints on generic types, some of which may not even be visible from the type signature, we currently think allowing FsCheck to generate a generic type is not worth the added complexity. It's very simple to fix any types anyway simply by adding some type annotations.

FsCheck can check properties of various forms - these forms are called testable, and are indicated in the API by a generic type called 'Testable. A 'Testable may be a function of any number of parameters that returns bool or unit. In the latter case, a test passes if it does not throw. The entry point to create properties is the Prop module.

Like all of FsCheck's API, there are C# counterparts for all of the F# methods described.

Conditional Properties

Properties may take the form <condition> ==> <property>

For example,

let insertKeepsOrder (x:int) xs = ordered xs ==> ordered (insert x xs)
Check.Quick insertKeepsOrder
Prop.ForAll<int, int[]>((x, xs) => xs.Insert(x).IsOrdered().When(xs.IsOrdered()))
Arguments exhausted after 16 tests.

Such a property holds if the property after ==> holds whenever the condition does.

Testing discards test cases which do not satisfy the condition. Test case generation continues until 100 cases which do satisfy the condition have been found, or until an overall limit on the number of test cases is reached (to avoid looping if the condition never holds). In this case a message such as "Arguments exhausted after 97 tests." indicates that 97 test cases satisfying the condition were found, and that the property held in those 97 cases.

Notice that in this case the generated values had to be restricted to int. This is because the generated values need to be comparable, but this is not reflected in the types. Therefore, without the explicit restriction, FsCheck could generate lists containing different types (subtypes of objects), and these are not mutually comparable.

Lazy Properties

Since F# has eager evaluation by default, the above property does more work than necessary: it evaluates the property at the right of the condition no matter what the outcome of the condition on the left. While only a performance consideration in the above example, this may limit the expressiveness of properties - consider:

let tooEager a = a <> 0 ==> (1/a = 1/a)
Check.Quick tooEager
Falsifiable, after 29 tests (0 shrinks) (StdGen (345295578,296303757)):
with exception:
System.DivideByZeroException: Attempted to divide by zero.
   at FSI_0025.tooEager(Int32 a) in C:\Users\Kurt\Projects\FsCheck\FsCheck\docs\tools\input.fsx:line 1
   at FsCheck.Testable.evaluate[a,b](FSharpFunc`2 body, a a) in C:\Users\Kurt\Projects\FsCheck\FsCheck\src\FsCheck\Testable.fs:line 151

Non-strict evaluation is needed here to make sure the propery is checked correctly:

let moreLazy a = a <> 0 ==> (lazy (1/a = 1/a))
Check.Quick moreLazy
Prop.ForAll<int>(a => new Func<bool>(() => 1 / a == 1 / a).When(a != 0))
Ok, passed 100 tests.

Quantified Properties

Properties may take the form forAll <arbitrary> (fun <args> -> <property>).

For example,

let orderedList = Arb.from<list<int>> |> Arb.mapFilter List.sort ordered
let insertWithArb x = Prop.forAll orderedList (fun xs -> ordered(insert x xs))
Check.Quick insertWithArb
var orderedList = Arb.From<int[]>()
                     .MapFilter(xs => xs.OrderBy(i => i).ToArray(), xs => xs.IsOrdered());

Prop.ForAll<int>(x => Prop.ForAll(orderedList, xs => xs.Insert(x).IsOrdered()))
Ok, passed 100 tests.

The first argument of forAll is an IArbitrary instance. Such an instance encapsulates a test data generator and a shrinker (more on that in Test Data). By supplying a custom generator, instead of using the default generator for that type, it is possible to control the distribution of test data. In the example, by supplying a custom generator for ordered lists, rather than filtering out test cases which are not ordered, we guarantee that 100 test cases can be generated without reaching the overall limit on test cases. Combinators for defining generators are described in Test Data.

Expecting exceptions

You may want to test that a function or method throws an exception under certain circumstances. Use throws<'e :> exn,'a> Lazy<'a> to achieve this. For example:

let expectDivideByZero() = Prop.throws<DivideByZeroException,_> (lazy (raise <| DivideByZeroException()))
Check.Quick expectDivideByZero
Ok, passed 100 tests.

This functionality is not available in the C# API.

Timed Properties

Properties may take the form within <timeout in ms> <Lazy<property>>

For example,

let timesOut (a:int) = 
        if a>10 then
            do System.Threading.Thread.Sleep(3000)
    |> Prop.within 1000
Check.Quick timesOut

The first argument is the time the lazy property may run. If it runs longer, FsCheck considers the test as failed. Otherwise, the outcome of the lazy property is the outcome of within. Note that, although within attempts to cancel the thread in which the property is executed, that may not succeed, and so the thread may actually continue to run until the process ends.

This functionality is not available in the C# API.

Observing Test Case Distribution

It is important to be aware of the distribution of test cases: if test data is not well distributed then conclusions drawn from the test results may be invalid. In particular, the ==> operator can skew the distribution of test data badly, since only test data which satisfies the given condition is used.

FsCheck provides several ways to observe the distribution of test data. Code for making observations is incorporated into the statement of properties, each time the property is actually tested the observation is made, and the collected observations are then summarized when testing is complete.

Counting Trivial Cases

A property may take the form trivial <condition> <property>

For example,

let insertTrivial (x:int) xs = 
  ordered xs ==> (ordered (insert x xs))
  |> Prop.trivial (List.length xs = 0)
Check.Quick insertTrivial
Prop.ForAll<int, int[]>((x, xs) =>
            .Classify(xs.Count() == 0, "trivial"))

Test cases for which the condition is true are classified as trivial, and the proportion of trivial test cases in the total is reported:

Arguments exhausted after 16 tests (37% trivial).

Classifying Test Cases

A property may take the form classify <condition> <string> <property>

For example,

let insertClassify (x:int) xs = 
  ordered xs ==> (ordered (insert x xs))
  |> Prop.classify (ordered (x::xs)) "at-head"
  |> Prop.classify (ordered (xs @ [x])) "at-tail"
Check.Quick insertClassify
Prop.ForAll<int, int[]>((x, xs) =>
        .Classify(new[] { x }.Concat(xs).IsOrdered(), "at-head")
        .Classify(xs.Concat(new int[] { x }).IsOrdered(), "at-tail"))

Test cases satisfying the condition are assigned the classification given, and the distribution of classifications is reported after testing:

Arguments exhausted after 16 tests.
37% at-tail, at-head.
31% at-head.
18% at-tail.

Note that a test case may fall into more than one classification.

Collecting Data Values

A property may take the form collect <expression> <property>

For example,

let insertCollect (x:int) xs = 
  ordered xs ==> (ordered (insert x xs))
      |> Prop.collect (List.length xs)
Check.Quick insertCollect
Prop.ForAll<int, int[]>((x, xs) =>
        .Collect("length " + xs.Count().ToString()))

The argument of collect is evaluated in each test case, and the distribution of values is reported. The type of this argument is printed using sprintf "%A":

Arguments exhausted after 15 tests.
46% 1.
26% 0.
13% 4.
13% 2.

Combining Observations

The observations described here may be combined in any way. All the observations of each test case are combined, and the distribution of these combinations is reported. For example:

let insertCombined (x:int) xs = 
    ordered xs ==> (ordered (insert x xs))
    |> Prop.classify (ordered (x::xs)) "at-head"
    |> Prop.classify (ordered (xs @ [x])) "at-tail"
    |> Prop.collect (List.length xs)
Check.Quick insertCombined
Prop.ForAll<int, int[]>((x, xs) =>
        .Classify(new [] { x }.Concat(xs).IsOrdered(), "at-head")
        .Classify(xs.Concat(new int[] { x }).IsOrdered(), "at-tail")
        .Collect("length " + xs.Count().ToString()))
Arguments exhausted after 20 tests.
40% 0, at-tail, at-head.
25% 1, at-head.
10% 2, at-head.
10% 1, at-tail.
5% 4.
5% 3.
5% 2, at-tail.

And, Or and Labels

Properties may take the form

  • <property> .&. <property> succeeds if both succeed, fails if one of the properties fails, and is rejected when both are rejected.
  • <property> .|. <property>succeeds if either property succeeds, fails if both properties fail, and is rejected when both are rejected.

The .&. combinator is most commonly used to write complex properties which share a generator. In that case, it might be difficult upon failure to know excactly which sub-property has caused the failure. That's why you can label sub-properties, and FsCheck shows the labels of the failed subproperties when it finds a counter-example. This takes the form: <string> @| <property> or <property> |@ <string>.

For example,

let complex (m: int) (n: int) =
  let res = n + m
  (res >= m)    |@ "result > #1" .&.
  (res >= n)    |@ "result > #2" .&. 
  (res < m + n) |@ "result not sum"
Check.Quick complex
Prop.ForAll<int, int>((m, n) => {
    var result = m + n;
    return (result >= m).Label("result > #1")
       .And(result >= n).Label("result > #2")
       .And(result < m + n).Label("result not sum");
Falsifiable, after 1 test (2 shrinks) (StdGen (353504692,296303757)):
Label of failing property: result not sum

It's perfectly fine to apply more than one label to a property; FsCheck displays all the applicable labels. This is useful for displaying intermediate results, for example:

let multiply (n: int, m: int) =
    let res = n*m
    sprintf "evidence = %i" res @| (
      "div1" @| (m <> 0 ==> lazy (res / m = n)) .&. 
      "div2" @| (n <> 0 ==> lazy (res / n = m)) .&. 
      "lt1"  @| (res > m) .&. 
      "lt2"  @| (res > n))
Check.Quick multiply
Prop.ForAll<int, int>((n, m) => {
    var res = n * m;
    return (new Func<bool>(() => res / m == n)).When(m != 0.0).Label("div1")
      .And((new Func<bool>(() => res / n == m)).When(n != 0.0).Label("div2"))
      .And((res > m).Label("lt1"))
      .And((res > n).Label("lt2"))
      .Label(string.Format("evidence = {0}", res));
Falsifiable, after 1 test (0 shrinks) (StdGen (354129700,296303757)):
Labels of failing property (one or more is failing):
evidence = 0
(0, 0)

Notice that the above property combines subproperties by tupling them. This works for tuples up to length 6 and lists:

  • (<property1>,<property2>,...,<property6>) means <property1> .&. <property2> .&.... .&.<property6>
  • [property1;property2,...,propertyN] means <property1> .&. <property2> .&.... .&.<propertyN>

The example written as a list:

let multiplyAsList (n: int, m: int) =
    let res = n*m
    sprintf "evidence = %i" res @| [
      "div1" @| (m <> 0 ==> lazy (res / m = n));
      "div2" @| (n <> 0 ==> lazy (res / n = m));
      "lt1"  @| (res > m);
      "lt2"  @| (res > n)]

Produces the same result.

Fork me on GitHub