Module B0_testing.Test

The type for text 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 while we wait for implicit source location support to be integrated in the compiler . The idea is that the argument is simply used with Stdlib.__POS__. For example:

Test.string s0 s1 ~__POS__

Logging.

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. Defaults to the basename of Sys.executable_name.

See an example.

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

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. See the cookbook.

autorun () calls all the tests defined by test and test', possibly filtered by the command line. args defines the value of test arguments.

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

skip fmt … logs fmt and skips the current block, test, 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 or block.

• error_to_failstop (Error e) is failstop "%s" e.
• error_to_failstop (Ok v) is v.

• error_to_fail (Error e) is fail "%s" e.
• error_to_fail (Ok v) is ().

block ~kind ~pass ~fail f runs f (), if that results in:

• n > 0 failed assertions, fail n ~assertions is called afterwards with assertions the total number of assertions that were performed. The default prints the fail to count ratio of assertions of type kind ("example", "test", etc.) if specified.
• f peforms a failstop the block is stopped but not the test. It is possible to fail stop the test by stoppping in the fail function.
• If no assertion fails pass is called with the number of assertions. Defaults does nothing, unless kind if specified in which case it indicates that count kinds passed.

For example if you are testing a list of examples use:

Test.block ~kind:"example" (fun () -> List.iter test_example examples)

This will log either the number of examples that succeeded or the ratio of failures. See this example in the cookbook.

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

dir () is the test directory. See the cookbook for more information.

The type for testable values.

Testers.

Reporting value differences.

Patching text and files.

The type for functions asserting 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.

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.

Randomized tests.

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 T.exn.

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.

Command line.

Formatters for test runners and tested values.