Module `Alcotest`Source

A lightweight and colourful test framework.

Alcotest provides a simple interface to perform unit tests. It exposes a simple TESTABLE module type, a check function to assert test predicates and a run function to perform a list of unit -> unit test callbacks.

From these descriptions, Alcotest builds a quiet and colorful output where only faulty runs are fully displayed at the end of the run (with the full logs ready to inspect).

Release 1.0.1

Sourcemodule Core : module type of Core

Sourcemodule Cli : module type of Cli

This module extends

Sourcemodule Monad : module type of Monad

include Cli.S with type return = unit

include Core.S with type return = unit

Sourcetype return = unit

Sourcetype speed_level = [

| `Quick
| `Slow

]

Speed level of a test. Tests marked as `Quick are always run. Tests marked as `Slow are skipped when the `-q` flag is passed.

Sourcetype 'a test_case = string * speed_level * ('a -> return)

A test case is an UTF-8 encoded documentation string, a speed level and a function to execute. Typically, the testing function calls the helper functions provided below (such as check and fail).

Sourceexception Test_error

The exception return by run in case of errors.

Sourceval test_case : string -> speed_level -> ('a -> return) -> 'a test_case

test_case n s f is the test case n running at speed s using the function f.

Sourcetype 'a test = string * 'a test_case list

A test is an US-ASCII encoded name and a list of test cases. The name can be used for filtering which tests to run on the CLI

Sourceval list_tests : 'a test list -> return

Print all of the test cases in a human-readable form

Source

type 'a with_options =
  ?and_exit:bool ->
  ?verbose:bool ->
  ?compact:bool ->
  ?tail_errors:[ `Unlimited | `Limit of int ] ->
  ?quick_only:bool ->
  ?show_errors:bool ->
  ?json:bool ->
  ?filter:(Re.re option * Core.IntSet.t option) ->
  ?log_dir:string ->
  'a

The various options taken by the tests runners run and run_with_args:

and_exit (default true). Once the tests have completed, exit with return code 0 if all tests passed, otherwise 1.
verbose (default false). Display the test std.out and std.err (rather than redirecting to a log file).
compact (default false). Compact the output of the tests.
tail_errors (default unlimited). Show only the last N lines of output of failed tests.
quick_only (default false). Don't run tests with the `Slow speed level.
show_errors (default false). Display the test errors.
json (default false). Print test results in a JSON-compatible format.
log_dir (default "$PWD/_build/_tests/"). The directory in which to log the output of the tests (if verbose is not set).

Source

val run : 
  (?argv:string array -> string -> unit test list -> return) with_options

run n t runs the test suite t. n is the name of the tested library.

The optional argument and_exit controls what happens when the function ends. By default, and_exit is set, which makes the function exit with 0 if everything is fine or 1 if there is an issue. If and_exit is false, then the function raises Test_error on error.

The optional argument argv specifies command line arguments sent to alcotest like "--json", "--verbose", etc. Note that this array will be treated like a regular Sys.argv, so the array must have at least one element, and the first element will be treated as if it was the command name and thus ignored for the purposes of option processing. So ~argv:[||] is an error, ~argv:[| "--verbose" |] will have no effect, and ~argv:[| "ignored"; "--verbose" |] will successfully pass the verbose option.

Source

val run_with_args : 
  (?argv:string array ->
    string ->
    'a Cmdliner.Term.t ->
    'a test list ->
    return)
    with_options

run_with_args n a t Similar to run a t but take an extra argument a. Every test function will receive as argument the evaluation of the Cdmliner term a: this is useful to configure the test behaviors using the CLI.

Assert functions

Sourcemodule type TESTABLE = sig ... end

TESTABLE provides an abstract description for testable values.

Sourcetype 'a testable = (module TESTABLE with type t = 'a)

The type for testable values.

Sourceval testable : 'a Fmt.t -> ('a -> 'a -> bool) -> 'a testable

testable pp eq is a new testable with the pretty-printer pp and equality eq.

Sourceval pp : 'a testable -> 'a Fmt.t

pp t is t's pretty-printer.

Sourceval equal : 'a testable -> 'a -> 'a -> bool

equal t is t's equality.

Sourceval bool : bool testable

bool tests booleans.

Sourceval int : int testable

int tests integers.

Sourceval int32 : int32 testable

int32 tests 32-bit integers.

Sourceval int64 : int64 testable

int64 tests 64-bit integers.

Sourceval float : float -> float testable

float tests floats with specified absolute error.

Sourceval char : char testable

char tests characters.

Sourceval string : string testable

string tests OCaml strings.

Sourceval unit : unit testable

unit tests unit values (useful for functions with side-effects).

Sourceval list : 'a testable -> 'a list testable

list t tests lists of ts.

Sourceval slist : 'a testable -> ('a -> 'a -> int) -> 'a list testable

slist t comp tests sorted lists of ts. The list are sorted using comp.

Sourceval array : 'a testable -> 'a array testable

array t tests arrays of ts.

Sourceval option : 'a testable -> 'a option testable

option t tests optional ts.

Sourceval result : 'a testable -> 'e testable -> ('a, 'e) result testable

result t e tests ts on success and es on failure.

Sourceval pair : 'a testable -> 'b testable -> ('a * 'b) testable

pair a b tests pairs of as and bs.

Sourceval of_pp : 'a Fmt.t -> 'a testable

of_pp pp tests values which can be printed using pp and compared using Pervasives.compare

Sourceval pass : 'a testable

pass tests values of any type and always succeeds.

Sourceval reject : 'a testable

reject tests values of any type and always fails.

Sourceval check : 'a testable -> string -> 'a -> 'a -> unit

Check that two values are equal.

Sourceval fail : string -> 'a

Simply fail.

Sourceval failf : ('a, Format.formatter, unit, 'b) format4 -> 'a

Simply fail with a formatted message.

Sourceval neg : 'a testable -> 'a testable

neg t is t's negation: it is true when t is false and it is false when t is true.

Sourceval check_raises : string -> exn -> (unit -> unit) -> unit

Check that an exception is raised.

package alcotest

Module AlcotestSource

Assert functions

Module `Alcotest`Source