module OUnit:sig..end
Unit test building blocks
Assertions are the basic building blocks of unittests.
val assert_failure : string -> 'aSignals a failure. This will raise an exception with the specified string.
Failure signal a failureval assert_bool : string -> bool -> unitSignals a failure when bool is false. The string identifies the failure.
Failure signal a failureval (@?) : string -> bool -> unitShorthand for assert_bool
Failure to signal a failureval assert_string : string -> unitSignals a failure when the string is non-empty. The string identifies the failure.
Failure signal a failureval assert_command : ?exit_code:Unix.process_status ->
?sinput:char Stdlib.Stream.t ->
?foutput:(char Stdlib.Stream.t -> unit) ->
?use_stderr:bool ->
?env:string array -> ?verbose:bool -> string -> string list -> unitassert_command prg args Run the command provided.
exit_code : expected exit codesinput : provide this char Stream.t as input of the processfoutput : run this function on output, it can contains an
assert_equal to check ituse_stderr : redirect stderr to stdoutenv : Unix environmentverbose : if failed, dump stdout/stderr of the process to stderrval assert_equal : ?cmp:('a -> 'a -> bool) ->
?printer:('a -> string) ->
?pp_diff:(Stdlib.Format.formatter -> 'a * 'a -> unit) ->
?msg:string -> 'a -> 'a -> unitassert_equal expected real Compares two values, when they are not equal a
failure is signaled.
Failure signal a failurecmp : customize function to compare, default is =printer : value printer, don't print value otherwisepp_diff : if not equal, ask a custom display of the difference
using diff fmt exp real where fmt is the formatter to usemsg : custom message to identify the failureval assert_raises : ?msg:string -> exn -> (unit -> 'a) -> unitAsserts if the expected exception was raised.
Failure descriptionmsg : identify the failureIn certain condition test can be written but there is no point running it, because they are not significant (missing OS features for example). In this case this is not a failure nor a success. Following functions allow you to escape test, just as assertion but without the same error status.
A test skipped is counted as success. A test todo is counted as failure.
val skip_if : bool -> string -> unitskip cond msg If cond is true, skip the test for the reason explain in
msg. For example skip_if (Sys.os_type = "Win32") "Test a doesn't run on.
windows"
val todo : string -> unitThe associated test is still to be done, for the reason given.
val cmp_float : ?epsilon:float -> float -> float -> boolCompare floats up to a given relative error.
epsilon : if the difference is smaller epsilon values are equalA bracket is a functional implementation of the commonly used setUp and tearDown feature in unittests. It can be used like this:
"MyTestCase" >:: (bracket test_set_up test_fun test_tear_down)
val bracket : (unit -> 'a) -> ('a -> unit) -> ('a -> unit) -> unit -> unitbracket set_up test tear_down The set_up function runs first, then
the test function runs and at the end tear_down runs. The
tear_down function runs even if the test failed and help to clean
the environment.
val bracket_tmpfile : ?prefix:string ->
?suffix:string ->
?mode:Stdlib.open_flag list ->
(string * Stdlib.out_channel -> unit) -> unit -> unitbracket_tmpfile test The test function takes a temporary filename
and matching output channel as arguments. The temporary file is created
before the test and removed after the test.
prefix : see Filename.open_temp_filesuffix : see Filename.open_temp_filemode : see Filename.open_temp_filetypetest_fun =unit -> unit
The type of test function
type test =
| |
TestCase of |
| |
TestList of |
| |
TestLabel of |
The type of tests
val (>:) : string -> test -> testCreate a TestLabel for a test
val (>::) : string -> test_fun -> testCreate a TestLabel for a TestCase
val (>:::) : string -> test list -> testCreate a TestLabel for a TestList
Some shorthands which allows easy test construction.
Examples:
"test1" >: TestCase((fun _ -> ())) =>
TestLabel("test2", TestCase((fun _ -> ())))"test2" >:: (fun _ -> ()) =>
TestLabel("test2", TestCase((fun _ -> ())))"test-suite" >::: ["test2" >:: (fun _ -> ());] =>
TestLabel("test-suite", TestSuite([TestLabel("test2",
TestCase((fun _ -> ())))]))val test_decorate : (test_fun -> test_fun) -> test -> testtest_decorate g tst Apply g to test function contains in tst tree.
val test_filter : ?skip:bool -> string list -> test -> test optiontest_filter paths tst Filter test based on their path string
representation.
skip : if set, just use skip_if for the matching tests.val test_case_count : test -> intReturns the number of available test cases
type node =
| |
ListItem of |
| |
Label of |
Types which represent the path of a test
typepath =node list
The path to the test (in reverse order).
val string_of_node : node -> stringMake a string from a node
val string_of_path : path -> stringMake a string from a path. The path will be reversed before it is tranlated into a string
val test_case_paths : test -> path listReturns a list with paths of the test
type test_result =
| |
RSuccess of |
| |
RFailure of |
| |
RError of |
| |
RSkip of |
| |
RTodo of |
The possible results of a test
type test_event =
| |
EStart of |
(* | A test start. | *) |
| |
EEnd of |
(* | A test end. | *) |
| |
EResult of |
(* | Result of a test. | *) |
Events which occur during a test run.
typetest_results =test_result list
Results of a test run.
val perform_test : (test_event -> unit) -> test -> test_resultsPerform the test, allows you to build your own test runner
val run_test_tt : ?verbose:bool -> test -> test_resultsA simple text based test runner.
verbose : print verbose messageval run_test_tt_main : ?arg_specs:(Stdlib.Arg.key * Stdlib.Arg.spec * Stdlib.Arg.doc) list ->
?set_verbose:(bool -> unit) -> test -> test_resultsMain version of the text based test runner. It reads the supplied command line arguments to set the verbose level and limit the number of test to run.
arg_specs : add extra command line argumentsset_verbose : call a function to set verbosityval ounit2_of_ounit1 : test -> OUnit2.test