module Test: sig
.. end
type 'a
cell
A single property test
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 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
t =
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 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
res =
| |
Success |
| |
Failure |
| |
FalseAssumption |
| |
Error of exn * string |
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 ->
?rand:Random.State.t -> 'a cell -> 'a QCheck.TestResult.t
check ~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