package qcheck-core

  1. Overview
  2. Docs

A test is a pair of an generator and a property thar all generated values must satisfy.

The main features of this module are:

  • make a test
  • fail the test if a property does not hold (using either the simple form or the rich form)
  • check_exn a single test

Note that while check_exn is provided for convenience to discover QCheck or to run a single test in utop, to run QCheck tests in your project you probably want to opt for a more advanced runner, or convert QCheck tests to your favorite test framework:

  • QCheck_base_runner for a QCheck-only runner (useful if you don't have or don't need another test framework)
  • QCheck_alcotest to convert to Alcotest framework
  • QCheck_ounit to convert to OUnit framework
type 'a cell

A single property test on a value of type 'a. A Test.t wraps a cell and hides its type parameter.

val make_cell : ?if_assumptions_fail:([ `Fatal | `Warning ] * float) -> ?count:int -> ?long_factor:int -> ?max_gen:int -> ?max_fail:int -> ?name:string -> ?print:'a Print.t -> ?collect:('a -> string) -> ?stats:'a stat list -> 'a Gen.t -> ('a -> bool) -> 'a cell

make_cell gen prop builds a test that checks property prop on instances of the generator gen.

  • parameter name

    the name of the test.

  • parameter count

    number of test cases to run, counting only the test cases which satisfy preconditions.

  • parameter long_factor

    the factor by which to multiply count, max_gen and max_fail when running a long test (default: 1).

  • parameter max_gen

    maximum number of times the generation function is called in total to replace inputs that do not satisfy preconditions (should be >= count).

  • parameter max_fail

    maximum number of failures before we stop generating inputs. This is useful if shrinking takes too much time.

  • parameter if_assumptions_fail

    the minimum fraction of tests that must satisfy the precondition for a success to be considered valid. The fraction should be between 0. and 1. A warning will be emitted otherwise if the flag is `Warning, the test will be a failure if the flag is `Fatal. (since 0.10)

  • parameter print

    used in Print to display generated values failing the prop

  • parameter collect

    (* collect values by tag, useful to display distribution of generated *)

  • parameter stats

    on a distribution of values of type 'a

val make_cell_from_QCheck1 : ?if_assumptions_fail:([ `Fatal | `Warning ] * float) -> ?count:int -> ?long_factor:int -> ?max_gen:int -> ?max_fail:int -> ?name:string -> gen:(Stdlib.Random.State.t -> 'a) -> ?shrink:('a -> ('a -> unit) -> unit) -> ?print:('a -> string) -> ?collect:('a -> string) -> stats:'a stat list -> ('a -> bool) -> 'a cell

⚠️ Do not use, this is exposed for internal reasons only. ⚠️

  • deprecated

    Migrate to QCheck2 and use make_cell instead.

val get_law : 'a cell -> 'a -> bool
val get_name : _ cell -> string
val get_gen : 'a cell -> 'a Gen.t
val get_print_opt : 'a cell -> 'a Print.t option
val get_collect_opt : 'a cell -> ('a -> string) option
val get_stats : 'a cell -> 'a stat list
val set_name : _ cell -> string -> unit
val get_count : _ cell -> int

Get the count of a cell.

  • since 0.5.3
val get_long_factor : _ cell -> int

Get the long factor of a cell.

  • since 0.5.3
type t =
  1. | Test : 'a cell -> t

    Same as 'a cell, but masking the type parameter. This allows to put tests on different types in the same list of tests.

val make : ?if_assumptions_fail:([ `Fatal | `Warning ] * float) -> ?count:int -> ?long_factor:int -> ?max_gen:int -> ?max_fail:int -> ?name:string -> ?print:'a Print.t -> ?collect:('a -> string) -> ?stats:'a stat list -> 'a Gen.t -> ('a -> bool) -> t

make gen prop builds a test that checks property prop on instances of the generator gen. See make_cell for a description of the parameters.

val test_get_count : t -> int
val fail_report : string -> 'a

Fail the test with some additional message that will be reported.

  • since 0.7
val fail_reportf : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a

Format version of fail_report.


  "Value N = %i should be greater than M = %i for Foo = %a" n m pp_foo foo
  • since 0.7

Running the test

include module type of Test_exceptions
exception Test_fail of string * string list

Exception raised when a test failed, with the list of counter-examples. Test_fail (name, l) means test name failed on elements of l.

exception Test_error of string * string * exn * string

Exception raised when a test raised an exception e, with the sample that triggered the exception. Test_error (name, i, e, st) means name failed on i with exception e, and st is the stacktrace (if enabled) or an empty string.

val print_instance : 'a cell -> 'a -> string
val print_c_ex : 'a cell -> 'a TestResult.counter_ex -> string
val print_fail : 'a cell -> string -> 'a TestResult.counter_ex list -> string
val print_fail_other : string -> msg:string -> string
val print_error : ?st:string -> 'a cell -> string -> ('a TestResult.counter_ex * exn) -> string
val print_test_fail : string -> string list -> string
val print_test_error : string -> string -> exn -> string -> string
val print_collect : (string, int) Stdlib.Hashtbl.t -> string

Print "collect" results.

  • since 0.6
val print_stat : ('a stat * (int, int) Stdlib.Hashtbl.t) -> string

Print statistics.

  • since 0.6
val check_result : 'a cell -> 'a TestResult.t -> unit

check_result cell res checks that res is Ok _, and returns unit. Otherwise, it raises some exception.

type res =
  1. | Success
  2. | Failure
  3. | FalseAssumption
  4. | Error of exn * string
type 'a event =
  1. | Generating
  2. | Collecting of 'a
  3. | Testing of 'a
  4. | Shrunk of int * 'a
  5. | Shrinking of int * int * 'a
type 'a handler = string -> 'a cell -> 'a event -> unit

Handler executed after each event during testing of an instance.

type 'a step = string -> 'a cell -> 'a -> res -> unit

Callback executed after each instance of a test has been run. The callback is given the instance tested, and the current results of the test.

type 'a callback = string -> 'a cell -> 'a TestResult.t -> unit

Callback executed after each test has been run. f name cell res means test cell, named name, gave res.

val check_cell : ?long:bool -> ?call:'a callback -> ?step:'a step -> ?handler:'a handler -> ?rand:Stdlib.Random.State.t -> 'a cell -> 'a TestResult.t

check_cell ~long ~rand test generates up to count random values of type 'a using Gen.t and the random state st. The predicate law is called on them and if it returns false or raises an exception then we have a counter-example for the law.

  • parameter long

    if true then multiply the number of instances to generate by the cell's long_factor.

  • parameter call

    function called on each test case, with the result.

  • parameter step

    function called on each instance of the test case, with the result.

  • returns

    the result of the test.

val check_cell_exn : ?long:bool -> ?call:'a callback -> ?step:'a step -> ?rand:Stdlib.Random.State.t -> 'a cell -> unit

Same as check_cell but calls check_result on the result.

val check_exn : ?long:bool -> ?rand:Stdlib.Random.State.t -> t -> unit

Checks the property against some test cases, and calls check_result, which might raise an exception in case of failure.


Innovation. Community. Security.