Up  

Module OUnit


module OUnit: sig .. end
The OUnit library can be used to implement unittests

To uses this library link with ocamlc oUnit.cmo or ocamlopt oUnit.cmx
Author(s): Maas-Maarten Zeeman


Assertions

Assertions are the basic building blocks of unittests.

val assert_failure : string -> 'a
Signals a failure. This will raise an exception with the specified string.
Raises Failure to signal a failure
val assert_bool : string -> bool -> unit
Signals a failure when bool is false. The string identifies the failure.
Raises Failure to signal a failure
val (@?) : string -> bool -> unit
Shorthand for assert_bool
Raises Failure to signal a failure
val assert_string : string -> unit
Signals a failure when the string is non-empty. The string identifies the failure.
Raises Failure to signal a failure
val assert_equal : ?cmp:('a -> 'a -> bool) ->
       ?printer:('a -> string) -> ?msg:string -> 'a -> 'a -> unit
Compares two values, when they are not equal a failure is signaled. The cmp parameter can be used to pass a different compare function. This parameter defaults to ( = ). The optional printer can be used to convert the value to string, so a nice error message can be formatted. When msg is also set it can be used to identify the failure.
Raises Failure description
val assert_raises : ?msg:string -> exn -> (unit -> 'a) -> unit
Asserts if the expected exception was raised. When msg is set it can be used to identify the failure
Raises Failure description

Skipping tests

In 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 function 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 -> unit
skip 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 -> unit
The associated test is still to be done, for the reason given.

Compare Functions

val cmp_float : ?epsilon:float -> float -> float -> bool
Compare floats up to a given relative error.

Bracket

A 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 -> 'b) -> ('a -> 'c) -> unit -> 'c

Constructing Tests

type test_fun = unit -> unit
The type of test function

type test =
| TestCase of test_fun
| TestList of test list
| TestLabel of string * test
The type of tests
val (>:) : string -> test -> test
Create a TestLabel for a test
val (>::) : string -> test_fun -> test
Create a TestLabel for a TestCase
val (>:::) : string -> test list -> test
Create a TestLabel for a TestList

Some shorthands which allows easy test construction.

Examples: 


val test_decorate : (test_fun -> test_fun) -> test -> test
test_decorate g tst Apply g to test function contains in tst tree.
val test_filter : string list -> test -> test option
test_filter paths tst Filter test based on their path string representation.

Retrieve Information from Tests

val test_case_count : test -> int
Returns the number of available test cases

type node =
| ListItem of int
| Label of string
Types which represent the path of a test
type path = node list
The path to the test (in reverse order).
val string_of_node : node -> string
Make a string from a node
val string_of_path : path -> string
Make a string from a path. The path will be reversed before it is tranlated into a string
val test_case_paths : test -> path list
Returns a list with paths of the test

Performing Tests


type test_result =
| RSuccess of path
| RFailure of path * string
| RError of path * string
| RSkip of path * string
| RTodo of path * string
The possible results of a test

type test_event =
| EStart of path
| EEnd of path
| EResult of test_result
Events which occur during a test run
val perform_test : (test_event -> 'a) -> test -> test_result list
Perform the test, allows you to build your own test runner
val run_test_tt : ?verbose:bool -> test -> test_result list
A simple text based test runner. It prints out information during the test.
val run_test_tt_main : test -> test_result list
Main 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