b1 ==> b2 is the logical implication b1 => b2 ie not b1 || b2 (except that it is strict and will interact better with Test.check_exn and the likes, because they will know the precondition was not satisfied.).

WARNING: this function should only be used in a property (see Test.make), because it raises a special exception in case of failure of the first argument, to distinguish between failed test and failed precondition. Because of OCaml's evaluation order, both b1 and b2 are always evaluated; if b2 should only be evaluated when b1 holds, see assume.

assume cond checks the precondition cond, and does nothing if cond=true. If cond=false, it interrupts the current test.

WARNING This function, like (==>), should only be used in a test, not outside. Example:

  Test.make (list int) (fun l ->
      assume (l <> []);
      List.hd l :: List.tl l = l)

• since 0.5.1

assume_fail () is like assume false, but can take any type since we know it always fails (like assert false). This is useful to ignore some branches in if or match.

Example:

  Test.make (list int) (function
      | [] -> assume_fail ()
      | _::_ as l -> List.hd l :: List.tl l = l)

• since 0.5.1

The Gen module offers combinators to build custom generators. Unlike the the 'a arbitrary record type, which comes with printers, shrinkers, etc. Gen.t represents a type for generation only.

The Print module offers combinators for printing generated values.

Iter is compatible with the library "sequence". An iterator i is simply a function that accepts another function f (of type 'a -> unit) and calls f on a sequence of elements f x1; f x2; ...; f xn.

The Shrink module contains combinators to build up composite shrinkers for user-defined types

A statistic on a distribution of values of type 'a. The function MUST return a positive integer.

A value of type 'a arbitrary is an object with a method for generating random values of type 'a, and additional methods to compute the size of values, print them, and possibly shrink them into smaller counter-examples.

NOTE the collect field is unstable and might be removed, or moved into Test.

Made private since 0.8

Builder for arbitrary. Default is to only have a generator, but other arguments can be added.

• parameter print

  printer for values (counter-examples)

• parameter collect

  for statistics

• parameter shrink

  to shrink counter-examples

• since 0.6

Update shrinker by only keeping smaller values satisfying the given invariant.

• since 0.8

Change the generator

• since 0.7

Add a statistic to the arbitrary instance.

• since 0.6

Access the underlying random generator of this arbitrary object.

• since 0.6

Access the underlying random generator of this arbitrary object.

• since 0.6

Always generates (), obviously.

Uniform boolean generator.

Generates regular floats (no nan and no infinities).

Positive float generator (no nan and no infinities).

Negative float generator (no nan and no infinities).

float_bound_inclusive n is uniform between 0 and n included. If bound is negative, the result is negative or zero. If bound is 0, the result is 0.

• since 0.11

float_bound_exclusive n is uniform between 0 included and n excluded. If bound is negative, the result is negative or zero.

• raises Invalid_argument

  if bound is zero.

• since 0.11

float_range low high is uniform between low included and high included.

• raises Invalid_argument

  if low > high or if the range is larger than max_float.

• since 0.11

exponential m generates floating-point numbers following an exponential distribution with a mean of m.

• raises Invalid_argument

  if m is NaN.

• since 0.23

Int generator. Uniformly distributed.

int_bound n is uniform between 0 and n included.

int_range a b is uniform between a and b included. b must be larger than a.

Small unsigned integers.

• since 0.5.1

Small unsigned integers. See Gen.small_int.

• deprecated

  use small_signed_int.

Small signed integers.

• since 0.5.2

Synonym for int_range.

Int32 generator. Uniformly distributed.

Int64 generator. Uniformly distributed.

Positive int generator (0 included). Uniformly distributed. See Gen.pint

As small_int, but each newly created generator starts with a list of corner cases before falling back on random generation.

Note that small_int_corners () is stateful, meaning that once the list of corner cases has been emitted, subsequent calls will not reproduce them. As a consequence, in the following example, the first test fails with a counter example, whereas the second rerun does not:

  let gen = QCheck.small_int_corners ()
  let t = QCheck.Test.make ~name:"never max_int" gen (fun i -> i <> max_int)
  let _ = QCheck_base_runner.run_tests ~verbose:true [t;t]

Negative int generator (0 included, see Gen.neg_int). The distribution is similar to that of small_int, not of pos_int.

Uniformly distributed on all the chars (not just ascii or valid latin-1).

Uniformly distributed over a subset of printable ascii chars. Ascii character codes 32 to 126, inclusive - or '\n' with code 10.

Uniformly distributed over '0'..'9'.

Builds a bytes generator from a (non-negative) size generator and a character generator.

• since 0.20

Generates bytes with a distribution of length of Gen.nat.

• since 0.20

Generates bytes with a distribution of length of Gen.nat and distribution of characters of char.

• since 0.20

Same as bytes but with a small length (ie Gen.small_nat ).

• since 0.20

Same as bytes_of but with a small length (ie Gen.small_nat ).

• since 0.20

Generates bytes with distribution of characters of char.

• since 0.20

Generates bytes with a distribution of length of Gen.nat and distribution of characters of printable_char.

• since 0.20

Builds a string generator from a (non-negative) size generator and a character generator.

Generates strings with a distribution of length of Gen.nat.

Synonym for string_gen added for convenience.

• since 0.20

Generates strings with a distribution of length of Gen.nat and distribution of characters of char.

Same as string but with a small length (ie Gen.small_nat ).

Synonym for small_string added for convenience.

• since 0.20

Same as string_of but with a small length (ie Gen.small_nat ).

• since 0.20

Generates lists of small size (see Gen.small_nat).

• since 0.5.3

Generates strings with distribution of characters of char.

Generates strings with a distribution of length of Gen.nat and distribution of characters of printable_char.

Synonym for printable_string added for convenience.

• since 0.20

Generates strings with distribution of characters of printable_char.

Synonym for printable_string_of_size added for convenience.

• since 0.20

Generates strings with a length of small_nat and distribution of characters of printable_char.

Synonym for small_printable_string added for convenience.

• since 0.20

Generates strings with a distribution of length of Gen.nat and distribution of characters of numeral_char.

Synonym for numeral_string added for convenience.

• since 0.20

Generates strings with a distribution of characters of numeral_char.

Synonym for numeral_string_of_size added for convenience.

• since 0.20

Generates lists with length generated by Gen.nat.

Generates lists with length from the given distribution.

Generates arrays with length generated by Gen.nat.

Generates arrays with length from the given distribution.

Choose between returning Some random value with optional ratio, or None.

result ~ratio okgen errgen generates Ok v with v coming from okgen or Error e with e coming from errgen, depending on ratio. The latter is a float between 0. and 1. indicating the probability of a sample to be Ok _ rather than Error _.

• since 0.24

Combines two generators into a generator of pairs. Order of elements can matter (w.r.t shrinking, see Shrink.pair)

Combines three generators into a generator of 3-tuples. Order matters for shrinking, see Shrink.pair and the likes

Combines four generators into a generator of 4-tuples. Order matters for shrinking, see Shrink.pair and the likes

Combines two generators into a 2-tuple generator. Order of elements can matter (w.r.t shrinking, see Shrink.tup2) Prints as many elements as available printers

Combines three generators into a 3-tuple generator. Order of elements can matter (w.r.t shrinking, see Shrink.tup2) Prints as many elements as available printers

Combines four generators into a 4-tuple generator. Order of elements can matter (w.r.t shrinking, see Shrink.tup2) Prints as many elements as available printers

Combines five generators into a 5-tuple generator. Order of elements can matter (w.r.t shrinking, see Shrink.tup2) Prints as many elements as available printers

Combines six generators into a 6-tuple generator. Order of elements can matter (w.r.t shrinking, see Shrink.tup2) Prints as many elements as available printers

Combines seven generators into a 7-tuple generator. Order of elements can matter (w.r.t shrinking, see Shrink.tup2) Prints as many elements as available printers

Combines eight generators into a 8-tuple generator. Order of elements can matter (w.r.t shrinking, see Shrink.tup2) Prints as many elements as available printers

Combines nine generators into a 9-tuple generator. Order of elements can matter (w.r.t shrinking, see Shrink.tup2) Prints as many elements as available printers

Choose among the given list of generators. The list must not be empty; if it is Invalid_argument is raised.

Pick an element randomly in the list.

Pick an element randomly in the array.

Pick a generator among the list, randomly.

• deprecated

  this function is badly specified and will not use shrinkers appropriately. Consider using Gen.oneof and then make to build a well behaved arbitrary instance.

Always return the same element.

Similar to oneof but with frequencies.

Same as oneofl, but each element is paired with its frequency in the probability distribution (the higher, the more likely).

Same as frequencyl, but with an array.

map f a returns a new arbitrary instance that generates values using a#gen and then transforms them through f.

• parameter rev

  if provided, maps values back to type 'a so that the printer, shrinker, etc. of a can be used. We assume f is monotonic in this case (that is, smaller inputs are transformed into smaller outputs).

Specialization of map when the transformation preserves the type, which makes shrinker, printer, etc. still relevant.

map_keep_input f a generates random values from a, and maps them into values of type 'b using the function f, but it also keeps the original value. For shrinking, it is assumed that f is monotonic and that smaller input values will map into smaller values.

• parameter print

  optional printer for the f's output.

Module to represent the result of running a test

Module related to individual tests. Since 0.18 most of it moved to QCheck2, and the type 'a cell was made a private implementation detail.

find_example ~f gen uses gen to generate some values of type 'a, and checks them against f. If such a value is found, it is returned. Otherwise an exception is raised. NOTE this should only be used from within a property in Test.make.

• parameter count

  number of attempts.

• parameter name

  description of the example to find (used in the exception).

• parameter f

  the property that the example must satisfy.

• raises No_example_found

  if no example is found within count tries.

• since 0.6

Toplevel version of find_example. find_example_gen ~f arb ~n is roughly the same as Gen.generate1 (find_example ~f arb |> gen).

• parameter rand

  the random state to use to generate inputs.

• raises No_example_found

  if no example was found within count tries.

• since 0.6

Observables are usable as arguments for random functions. The random function will observe its arguments in a way that is determined from the observable instance.

Generator of functions of arity 1. The functions are always pure and total functions:

• when given the same argument (as decided by Stdlib.(=)), it returns the same value
• it never does side effects, like printing or never raise exceptions etc. The functions generated are really printable.

renamed from fun1 since 0.6

• deprecated

  use fun_ instead.

• since 0.6

Generator of functions of arity 2. The remark about fun1 also apply here. renamed from fun2 since 0.6

• deprecated

  use fun_ instead since 0.6

Internal data for functions. A 'f fun_ is a function of type 'f, fundamentally.

A function packed with the data required to print/shrink it. See Fn to see how to apply, print, etc. such a function.

One can also directly pattern match on it to obtain the executable function.

For example:

  QCheck.Test.make
    QCheck.(pair (fun1 Observable.int bool) (small_list int))
    (fun (Fun (_,f), l) -> l=(List.rev_map f l |> List.rev l))

A utility module of helpers for printing, shrinking, and applying generated function values.

fun1 o ret makes random functions that take an argument observable via o and map to random values generated from ret. To write functions with multiple arguments, it's better to use Tuple or Observable.pair rather than applying fun_ several times (shrinking will be faster).

• since 0.6

• since 0.6

• since 0.6

• since 0.6

fun_nary makes random n-ary functions. Example:

  let module O = Observable in
  fun_nary Tuple.(O.int @-> O.float @-> O.string @-> o_nil) bool

• since 0.6