alcotest 1.3.0 · OCaml Package

module type TESTABLE = sig ... end

TESTABLE provides an abstract description for testable values.

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

The type for testable values.

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

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

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

pp t is t's pretty-printer.

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

equal t is t's equality.

val bool : bool testable

bool tests booleans.

val int : int testable

int tests integers.

val int32 : int32 testable

int32 tests 32-bit integers.

val int64 : int64 testable

int64 tests 64-bit integers.

val float : float -> float testable

float tests floats with specified absolute error.

val char : char testable

char tests characters.

val string : string testable

string tests OCaml strings.

val bytes : bytes testable

bytes tests OCaml bytes.

val unit : unit testable

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

val list : 'a testable -> 'a list testable

list t tests lists of ts.

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

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

val array : 'a testable -> 'a array testable

array t tests arrays of ts.

val option : 'a testable -> 'a option testable

option t tests optional ts.

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

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

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

pair a b tests pairs of as and bs.

val triple : 
  'a testable ->
  'b testable ->
  'c testable ->
  ('a * 'b * 'c) testable

triple a b c tests triples of as, bs and cs.

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

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

val pass : 'a testable

pass tests values of any type and always succeeds.

val reject : 'a testable

reject tests values of any type and always fails.

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

Check that two values are equal.

val check' : 'a testable -> msg:string -> expected:'a -> actual:'a -> unit

Check that two values are equal (labeled variant of check).

val fail : string -> 'a

Simply fail.

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

Simply fail with a formatted message.

val 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.

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

Check that an exception is raised.

package alcotest