`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 -> ?negative:bool -> ?max_gen:int -> ?max_fail:int -> ?retries: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 negative

  whether the test is expected not to satisfy the tested property.

- 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 retries

  number of times to retry the tested property while shrinking.

- 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 -> ?negative:bool -> ?max_gen:int -> ?max_fail:int -> ?retries: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`

Get the tested property of a cell.

`val get_name : _ cell -> string`

Get the tested property of a cell.

Get the name of a cell.

`val get_gen : 'a cell -> 'a Gen.t`

Get the name of a cell.

Get the generator of a cell.

`val get_print_opt : 'a cell -> 'a Print.t option`

Get the generator of a cell.

Get the optional printer of a cell.

`val get_collect_opt : 'a cell -> ('a -> string) option`

Get the optional printer of a cell.

Get the optional to-string collector of a cell.

`val get_stats : 'a cell -> 'a stat list`

Get the optional to-string collector of a cell.

Get the statistics of a cell.

`val set_name : _ cell -> string -> unit`

Get the statistics of a cell.

Set the name of a cell.

`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

`val get_positive : _ cell -> bool`

Get the expected mode of a cell: positive indicates expected to satisfy the tested property, negative indicates expected not to satisfy the tested property.

`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 -> ?retries: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 make_neg : ?if_assumptions_fail:([ `Fatal | `Warning ] * float) -> ?count:int -> ?long_factor:int -> ?max_gen:int -> ?max_fail:int -> ?retries:int -> ?name:string -> ?print:'a Print.t -> ?collect:('a -> string) -> ?stats:'a stat list -> 'a Gen.t -> ('a -> bool) -> t`

`make_neg gen prop` builds a test that checks property `prop` on instances of the generator `gen`. The test is considered negative, meaning that it is expected not to satisfy the tested property. This information is recorded in an underlying test `cell` entry and interpreted suitably by test runners. See `make_cell` for a description of the parameters.

`val test_get_count : t -> int`
`val test_get_long_factor : 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`.

Example:

      Test.fail_reportf
        "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.

`exception Test_unexpected_success of string`

Exception raised when a negative test failed. `Test_unexpected_success name` means test `name` failed to find an expected counter example.

`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_expected_failure : 'a cell -> 'a TestResult.counter_ex list -> 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`

For a positive test `check_result cell res` checks that `res` is `Ok _`, and returns unit. For a negative test `check_result cell res` checks that `res` is `Failed _`, and returns unit. Otherwise, it raises some exception.

- raises `Test_fail`

  if the test is positive and `res = Failed _`

- raises `Test_unexpected_success`

  if the test is negative and `res = Ok _`

- raises `Test_error`

  if `res = Error _`

`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`.

Note: `check_cell` ignores a test's polarity, acting as described above regardless of whether the tested cell is a positive or negative test.

- 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 -> ?handler:'a handler -> ?rand:Stdlib.Random.State.t -> 'a cell -> unit`

Same as `check_cell` but calls `check_result` on the result. `check_cell test` honors test polarity and thus expects positive tests to succeed without finding a counterexample and expects negative tests to fail by finding one.

- raises `Test_fail`

  if the test is positive and `res = Failed _`

- raises `Test_unexpected_success`

  if the test is negative and `res = Success _`

- raises `Test_error`

  if `res = Error _`

`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. `check_exn test` honors test polarity and thus expects positive tests to succeed without finding a counterexample and expects negative tests to fail by finding one.

- raises `Test_fail`

  if the test is positive and `res = Failed _`

- raises `Test_unexpected_success`

  if the test is negative and `res = Success _`

- raises `Test_error`

  if `res = Error _`