Module OUnitTest

module OUnitTest: sig .. end

See OUnit.mli.

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 Pervasives.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 Pervasives.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: Map.Make(Path)

val string_of_path : node list -> string

val test_case_paths : test -> node list list

module SetTestPath: Set.Make(String)

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