The type for test source locations. This is the type of Stdlib.__POS_OF__.

It is an optional argument of most combinators to keep track of precise locations of failures. The idea is that the argument is simply used with Stdlib.__POS__. For example:

Test.string s0 s1 ~__POS__

The type for log functions. If __POS__ is specified starts by logging the position on a line before logging the format.

log fmt … logs a message formatted by fmt.

log_pass fmt … is like log but formatted for passing. This does not increment passed assertions, use pass to do so.

log_fail fmt … is like log but formatted for failures. This does not increment failed assertions, use fail to register a failure.

log_start is like log but does not finish the line. log_end does.

log_finish ends a line started with log_start.

log_raw fmt … outputs to the test log.

main f executes f (), logs the resulting testing status and returns 0 if all tests passed and 1 otherwise to be given to Stdlib.exit. Usually f calls functions that call test.

• doc is a synopsis for the test executable.
• name is a name for the test executable.

See an example.

main' is like main but allows to define your own additional command line.

set_main_exit f will disable the final report performed by main and invoke f instead. TODO. A bit ad-hoc.

Test arguments.

test name f is a test that when run logs "Test %s" name and executes f (). The test fails if any failure is reported in f or if f raises an unexpected exception. If long is true, this is a long test an only run when explicitely requested. See examples.

test' arg is like test but takes an argument.

autorun () calls all the tests defined by test and test', possibly filtered by the command line. For the latter an argument value should be provided in args (defaults to []).

stop () stops the current block, test, or main. Note that this does not increment failed assertions, use fail or failstop for that.

skip () skips the current block, test, or main.

pass () increments the number of successfull assertions.

fail fmt … increments the number of failed assertions and logs fmt with log_fail. The test or block continues to execute, use stop or failstop to stop the test.

failf fmt … is like fail but also stops the test.

block ~fail f runs f (), if that results in n > 0 failed assertions, fail n ~assertions is called afterwards with assertoins the total number of assertions that were performed. If f peforms a failstop the block is stopped but not the test. It is possible to fail stop the test by stoppping in fail.

TODO. Should we simply make blocks nested tests ?

range ~first ~last f calls f n with n ranging over the range [first;last]. If a failure occurs for n, logs "%s in range [%d;%d] failed on %d" kind first last n. If f performs a failstop the loop is stopped but not the test. kind defaults to "Test".

The type for testable values.

Testers.

Reporting value differences.

Patching text and files.

The type for functions aasserting equality. diff indicates how to report differences on mismatches.

eq t fnd exp assert fnd and exp are equal using tester t.

Convention. When testing values we assume that the second value is the expected argument and the first one the value against which it is checked.

neq t fnd exp assert fnd and exp are not equal using tester t.

holds b asserts that b is true. msg is logged if the assertion fails.

noraise f tests that f () does not raise an exception and fail stops if it does except if this is a B0_std.Os.exn_don't_catch exception.

catch f k calls f () and gives the exception it raises to k or fails otherwise. ret is used to print an offending returned value. B0_std.Os.exn_don't_catch exceptions are not catched.

ex is eq Exceptions.

raises exn f tests that f () raises exception exn. B0_std.Os.exn_don't_catch exceptions are not catched.

invalid_arg f tests that f () raises Invalid_argument _. Note. It is usually better to use Snap.raise as it allows to keep track of the error message.

failure f tests that f () raises Failure _. Note. It is usually better to use Snap.raise as it allows to keep track of the error message.

unit is eq T.unit.

bool is eq T.bool.

int is eq T.int.

int32 is eq T.int32.

uint32 is eq T.uint32.

int64 is eq T.int64.

uint64 is eq T.uint64.

nativeint is eq T.nativeint.

nativeuint is eq T.nativeuint.

float is eq T.float.

char is eq T.char.

string is eq T.string. Assumes UTF-8 encoded strings.

lines is eq T.lines. Assumes UTF-8 encoded strings.

binary_string is eq T.binary_string. Assumes arbitrary binary strings.

styled_string is eq T.styled_string. Assumes strings with ANSI escape sequences.

string is eq T.bytes.

any uses T.any.

option some is eq (T.option some).

either ~left ~right is eq (T.either ~left ~right).

result ~ok is eq (T.result ~ok).

result' ~ok ~error is eq (T.result' ~ok ~error).

list elt is eq (T.list elt).

array elt is eq (T.array elt).

pair fst snd is eq (T.pair fst snd).

t2 is pair.

t3 is eq for triplets.

t4 is eq for quadruplets.

t5 is eq for quintuplets.

t6 is eq for sextuplets.

Randomized testing.

Snapshot tests.

The type for snapshot functions.

snap t fnd @@ __POS_OF__ exp compares snapshot fnd to exp. subst is used to correct snapshots, it defaults to Snapshot.generic_subst which depends on t's pretty printer formatting valid OCaml code.

See B0_testing.Snap for preapplied combinators.

Command line.

Formatters for test runners and tested values.