module Test: sig .. end
type 'a cell
A single property test
val fail_report : string -> 'a
Fail the test with some additional message that will
be reported.
Since 0.7
val fail_reportf : ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
val make_cell : ?count:int ->
?long_factor:int ->
?max_gen:int ->
?max_fail:int ->
?small:('a -> int) ->
?name:string -> 'a QCheck.arbitrary -> ('a -> bool) -> 'a cell
make_cell arb prop builds a test that checks property prop on instances
of the generator arb.
count : number of test cases to run, counting only
the test cases which satisfy preconditions.
long_factor : the factor by which to multiply count, max_gen and
max_fail when running a long test (default: 1).
max_gen : maximum number of times the generation function
is called in total to replace inputs that do not satisfy
preconditions (should be >= count).
max_fail : maximum number of failures before we stop generating
inputs. This is useful if shrinking takes too much time.
small : kept for compatibility reasons; if provided, replaces
the field arbitrary.small.
If there is no shrinking function but there is a small
function, only the smallest failures will be printed.
name : the name of the test.
val get_arbitrary : 'a cell -> 'a QCheck.arbitrary
val get_law : 'a cell -> 'a -> bool
val get_name : 'a cell -> string
val set_name : 'a cell -> string -> unit
val get_count : 'a cell -> int
Get the count of a cell.
Since 0.5.3
val get_long_factor : 'a cell -> int
Get the long factor of a cell.
Since 0.5.3
type
val make : ?count:int ->
?long_factor:int ->
?max_gen:int ->
?max_fail:int ->
?small:('a -> int) ->
?name:string -> 'a QCheck.arbitrary -> ('a -> bool) -> t
make arb prop builds a test that checks property
prop on instances
of the generator
arb.
See
QCheck.Test.make_cell for a description of the parameters.
Running the test
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 QCheck.arbitrary -> 'a -> string
val print_c_ex : 'a QCheck.arbitrary -> 'a QCheck.TestResult.counter_ex -> string
val print_fail : 'a QCheck.arbitrary ->
string -> 'a QCheck.TestResult.counter_ex list -> string
val print_error : ?st:string ->
'a QCheck.arbitrary ->
string -> 'a QCheck.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) Hashtbl.t -> string
Print "collect" results.
Since 0.6
val print_stat : 'a QCheck.stat * (int, int) Hashtbl.t -> string
Print statistics.
Since 0.6
val check_result : 'a cell -> 'a QCheck.TestResult.t -> unit
check_result cell res checks that
res is
Ok _, and returns unit.
Otherwise, it raises some exception.
RaisesTest_error if res = Error _Test_error if res = Failed _
type
| |
Success |
| |
Failure |
| |
FalseAssumption |
| |
Error of exn * string |
type 'a event =
| |
Generating |
| |
Collecting of 'a |
| |
Testing of 'a |
| |
Shrunk of int * 'a |
| |
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 QCheck.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:Random.State.t -> 'a cell -> 'a QCheck.TestResult.t
check_cell ~long ~rand test generates up to count random
values of type 'a using arbitrary 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.
Returns the result of the test.
long : if true then multiply the number of instances to generate
by the cell's long_factor.
call : function called on each test case, with the result.
step : function called on each instance of the test case, with the result.
val check_cell_exn : ?long:bool ->
?call:'a callback ->
?step:'a step ->
?rand:Random.State.t -> 'a cell -> unit
val check_exn : ?long:bool -> ?rand:Random.State.t -> t -> unit