OUnit user guide : OUnitTest

# Module OUnitTest

    module OUnitTest: sig .. end

    exception Skip of string

    exception Todo of string

    exception OUnit_failure of string

    type node =

`|` | `ListItem of `int``
`|` | `Label of `string``

See OUnit.mli.

    type path = node list

See OUnit.mli.

    type backtrace = string option

See OUnit2.mli.

    type test_length =

`|` | `Immediate`
`|` | `Short`
`|` | `Long`
`|` | `Huge`
`|` | `Custom_length of `float``

    type result =

`|` | `RSuccess`
`|` | `RFailure of `string * OUnitLogger.position option * backtrace``
`|` | `RError of `string * backtrace``
`|` | `RSkip of `string``
`|` | `RTodo of `string``
`|` | `RTimeout of `test_length``

See OUnit.mli.

    type result_full = path * result * OUnitLogger.position option

    type result_list = result_full list

    type ctxt = {

`` | `conf : `OUnitConf.conf`;`
`` | `logger : `(path, result) OUnitLogger.logger`;`
`` | `shared : `OUnitShared.shared`;`
`` | `path : `path`;`
`` | `test_logger : `result OUnitLogger.Test.t`;`
`` | `mutable tear_down : `(ctxt -> unit) list`;`
`` | `tear_down_mutex : `OUnitShared.Mutex.t`;`
`` | `non_fatal : `result_full list Stdlib.ref`;`
`` | `non_fatal_mutex : `OUnitShared.Mutex.t`;`

}

    type log_event_t = (path, result) OUnitLogger.log_event_t

    type logger = (path, result) OUnitLogger.logger

    type test_fun = ctxt -> unit

    type test =

`|` | `TestCase of `test_length * test_fun``
`|` | `TestList of `test list``
`|` | `TestLabel of `string * test``

    val delay_of_length : test_length -> float

    val get_shard_id : ctxt -> string

    val section_ctxt : ctxt -> (ctxt -> 'a) -> 'a

Isolate a function inside a context. All the added tear down will run before returning.

    val with_ctxt : OUnitConf.conf ->
           (path, result) OUnitLogger.logger ->
           OUnitShared.shared ->
           result_full list Stdlib.ref ->
           path -> (ctxt -> 'a) -> 'a

Create a context and run the function.

    val standard_modules : string list

    val result_full_of_exception : ctxt ->
           exn -> path * result * OUnitLogger.position option

Transform an exception in a result.

    val report_result_full : ctxt ->
           path * result * 'a ->
           path * result * 'a

    val non_fatal : ctxt -> (ctxt -> unit) -> unit

Isolate a function inside a context, just as `!section_ctxt` but don't propagate a failure, register it for later.

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

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

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

    val test_decorate : (test_fun -> test_fun) ->
           test -> test

    val test_case_count : test -> int

    val string_of_node : node -> string

    module Path: sig .. end

    module MapPath: Stdlib.Map.Make(Path)

    val string_of_path : node list -> string

    val test_case_paths : test -> node list list

    module SetTestPath: Stdlib.Set.Make(Stdlib.String)

    val test_filter : ?skip:bool ->
           SetTestPath.elt list -> test -> test option