# 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

##### 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 =`

`|` | `TestCase of `(unit -> unit)``
`|` | `TestList of `test list``
`|` | `TestLabel of `string * test``

The type of tests

    val (>:) : string -> test -> test

Create a TestLabel for a test

    val (>::) : string -> (unit -> unit) -> 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:

- `"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 _ -> ())))]))`

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

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