Index of values

Shorthand for logand_list.

Shorthand for logand.

Shorthand for Specification.logand function.

Shorthand for implies'.

Shorthand for Specification.implies' function.

Shorthand for implies.

Shorthand for Specification.implies function.

Bare synonym for redirect_output.

Shorthand for Shell.redirect_output function.

Bare synonym for redirect_append.

Shorthand for Shell.redirect_append function.

Bare synonym for redirect_error.

Shorthand for Shell.redirect_error function.

Bare synonym for redirect_append_error.

Shorthand for Shell.redirect_append_error function.

Shorthand for logxor.

Shorthand for Specification.logxor function.

Shorthand for logxor_list.

Bare synonym for pipe.

Shorthand for Shell.pipe function.

Shorthand for logor.

Shorthand for Specification.logor function.

Shorthand for logor_list.

Equivalent to make_assert_test, except that the built test is added to the ones to be run by launch_tests.

Equivalent to make_enum_test, except that the built test is added to the ones to be run by launch_tests.

Equivalent to make_partial_enum_test, except that the built test is added to the ones to be run by launch_tests.

Equivalent to make_partial_random_test, except that the built test is added to the ones to be run by launch_tests.

Equivalent to make_random_test, except that the built test is added to the ones to be run by launch_tests.

Equivalent to make_shell_test, except that the built test is added to the ones to be run by launch_tests.

Equivalent to make_simple_test, except that the built test is added to the ones to be run by launch_tests.

Generator for char values representing alphanumeric characters (i.e.

Predicate that always evaluates to true.

apply1 f x is equivalent to f x.

apply2 f (x, y) is equivalent to f x y.

apply3 f (x, y, z) is equivalent to f x y z.

apply4 f (x, y, z, t) is equivalent to f x y z t.

apply5 f (x, y, z, t, u) is equivalent to f x y z t u.

Reducer for array values.

array l e constructs a generator for arrays.

array e l constructs an enumerator for arrays of length l, e is used to generate the array elements.

Equivalent to Filename.basename.

The configuration for bash shells.

Reducer for bool values.

Generator for bool values.

Enumerator for bool values.

buffer b constructs a generator for Buffer.t values.

buffer e l constructs an enumerator for buffers of length l, e is used to generate the buffer elements.

Returns the list of parameter values passed to the function.

cat ~options:options l builds a command displaying elements from l, passing options to the cat executable.

Changes the current directory to the value of the passed argument.

Reducer for char values.

Generator for char values.

Enumerator for char values.

Equivalent to cd, as a command.

check ... is equivalent to run_test (make_random_test ...).

Shorthand for Test.check function.

Equivalent to check for partial functions.

Shorthand for Test.check_partial function.

Equivalent to Filename.check_suffix.

choose_array a constructs a generator that returns an element by first selecting a generator from a and using it to generate the actual value.

choose_array_weigthed a constructs a generator that returns an element by first selecting a generator from a and using it to generate the actual value.

choose_list l constructs a generator that returns an element by first selecting a generator from l and using it to generate the actual value.

choose_list_weighted l constructs a generator that returns an element by first selecting a generator from l and using it to generate the actual value.

Equivalent to Filename.chop_extension.

Equivalent to Filename.chop_suffix.

coerce c allows one to change the parameter types of the command type.

command s lifts s to a command.

Reducer for Complex.t values.

complex r i constructs a generator for Complex.t values.

complex re im constructs an enumerator for Complex.t values, using re and im to respectively generate the real and imaginary parts.

Equivalent to Filename.concatname.

count f x returns how many time the function f has been called with a parameter value equal to x.

cp ~options:options l d builds a command copying elements from l to d, passing options to the cp executable.

Equivalent to Filename.current_dir_name.

cut ~options:options l builds a command extract elements from the data it receives, passing options to the cut executable.

The default classifier, always returning "".

Default printer, always returning "".

The default reducer, always returning [].

diff ~options:options x y builds a command computing the difference between x and y, passing options to the diff executable.

Generator for char values representing (decimal) digits.

Generator for char values representing (binary) digits.

Generator for char values representing (hexadecimal) digits.

Generator for char values representing (octal) digits.

Equivalent to Filename.dirname.

echo ~options:options x builds a command printing x, passing options to the echo executable.

Dummy empty enumerator.

Same as equal, but specialized for set values.

equal ~eq:e ~prn:p ~msg:m x y raises Failed if x and y are not equal, relatively to the equality function e.

Same as equal, but specialized for bool values.

Same as equal, but specialized for char values.

Same as equal, but specialized for Complex.t values.

Same as equal, but specialized for float values.

Same as equal, but specialized for int values.

Same as equal, but specialized for int32 values.

Same as equal, but specialized for int64 values.

Same as equal, but specialized for nativeint values.

Same as equal, but specialized for string values.

Executes the passed test, returning its outcome.

exec_tests l is equivalent to List.map exec_test l.

Predicates that evaluates to true iff any of the weak hashtable elements makes P.p evaluate to true.

Predicates that evaluates to true iff any of the set elements makes P.p evaluate to true.

exists p constructs a predicate that evaluates to true iff any of the map element (k, v) makes P.p k && p v evaluate to true.

exists_array p constructs a predicate that evaluates to true iff any of the elements makes p evaluate to true.

exists_hashtbl p constructs a predicate that evaluates to true iff any of the elements makes p evaluate to true.

exists_list p constructs a predicate that evaluates to true iff any of the elements makes p evaluate to true.

exists_queue p constructs a predicate that evaluates to true iff any of the elements makes p evaluate to true.

exists_stack p constructs a predicate that evaluates to true iff any of the elements makes p evaluate to true.

exists_string p constructs a predicate that evaluates to true iff any of the characters makes p evaluate to true.

exists_weak p constructs a predicate that evaluates to true iff any of the elements makes p evaluate to true.

exit n builds a command returning the exit code n.

Raises Failed with the passed parameters (expected value, actual value, and message).

fail_msg m is equivalent to fail "" "" m.

file_bytes fn constructs an enumerator returning the bytes from file fn.

file_chars fn constructs an enumerator returning the characters from file fn.

Synonym for Sys.file_exists.

file_lines fn constructs an enumerator returning the lines from file fn.

file_values fn p constructs an enumerator returning the values (as stored by marshalling) from file fn, using p to convert elements into their string representation.

Equivalent to Sys.readdir except that a list is returned.

Equivalent to files except that the returned list is filtered by the passed function.

files_with_suffix s d equivalent to files d except that only the files with the suffix s are returned.

filter f g constructs a generator equivalent to g filtered by f, that is skips all values x such that f x returns false.

filter f e constructs an enumerator equivalent to e filtered by f, that is skips all values x such that f x returns false.

Reducer for float values.

Generator for float values.

float x y steps constructs an enumerator for float values between x and y, producing steps values.

Predicates that evaluates to true iff all of the weak hashtable elements make P.p evaluate to true.

Predicates that evaluates to true iff all of the set elements make P.p evaluate to true.

for_all p constructs a predicate that evaluates to true iff all of the map elements (k, v) make P.p k && p v evaluate to true.

for_all_array p constructs a predicate that evaluates to true iff all of the elements make p evaluate to true.

for_all_hashtbl p constructs a predicate that evaluates to true iff all of the elements make p evaluate to true.

for_all_list p constructs a predicate that evaluates to true iff all of the elements make p evaluate to true.

for_all_queue p constructs a predicate that evaluates to true iff all of the elements make p evaluate to true.

for_all_stack p constructs a predicate that evaluates to true iff all of the elements make p evaluate to true.

for_all_string p constructs a predicate that evaluates to true iff all of the characters make p evaluate to true.

for_all_weak p constructs a predicate that evaluates to true iff all of the elements make p evaluate to true.

for_each x y f constructs an enumerator that is the concatenation of the enumerators f i where i successively takes the values from x to y (both inclusive).

from_function ~cmp f returns a mock function based on the function f, only recording calls actually made to the function.

from_mapping ~cmp ~prn l returns a mock function based on the association list l whose couples are (input, output) indicating that the function should return output when call with paramer input.

from_sequence ~cmp ~prn l returns a mock function based on the association list l whose couples are (input_i, output_i) indicating that the ith call to the function should have parameter input_i and should return output_i.

Returns the function bare to be used for tests.

Returns the function bare to be used for tests, as a binary function.

Returns the function bare to be used for tests, as a ternary function.

Returns the function bare to be used for tests, as a quaternary function.

Returns the function bare to be used for tests, as a quinary function.

Actual generator for g values.

gen i constructs a generator for weak hashtables of G.g values.

gen i constructs a generator for sets of G.g values.

gen i g constructs a generator for maps from G.g to 'a.

Returns the list that tests that would be run by launch_tests.

Synonym for Sys.getenv.

grep ~options:options x builds a command filtering the input with the expression x, passing options to the grep executable.

grep_files ~options:options x l builds a command filtering the files from l with the expression x, passing options to the grep executable.

Reducer for Hashtbl.t values.

hashtbl s k v constructs a generator for Hashtbl.t values.

A specialized version of coerce that ignores both outputs.

implies p1 p2 is equivalent to { precond = p1; postcond = p2 }.

implies' p1 p2 is a simplified version of implies where the predicate of the postcondition is only applied to the function result.

Reducer for int values.

Generator for int values.

int x y constructs an enumerator for int values between x and y (both inclusive).

Reducer for int32 values.

Generator for int32 values.

int32 x y constructs an enumerator for int32 values between x and y (both inclusive).

Reducer for int64 values.

Generator for int64 values.

int64 x y constructs an enumerator for int64 values between x and y (both inclusive).

Predicate testing whether the char argument is either an underscore or a letter/digit.

Predicate testing whether the char argument is a (binary) digit.

Predicate testing whether the char argument is a (decimal) digit.

Predicate testing whether the char argument is a (hexadecimal) digit.

Predicate testing whether the char argument is a (octal) digit.

Synonym for Sys.is_directory.

Predicate testing whether the array argument is empty.

Predicate testing whether the list argument is empty.

Predicate testing whether the string argument is empty.

Predicate testing whether the int argument is even.

Predicate testing whether the int32 argument is even.

Predicate testing whether the int64 argument is even.

Predicate testing whether the nativeint argument is even.

is_exception p returns a predicate that ensures that the outcome is an exception satisfying predicate p.

is_false ~msg:m x raises Failed if x is true.

Equivalent to Filename.is_implicit.

Predicate testing whether the char argument is a letter.

Predicate testing whether the float argument is equal to nan.

Predicate testing whether the float argument is lower than or equal to zero.

Predicate testing whether the int argument is lower than or equal to zero.

Predicate testing whether the int32 argument is lower than or equal to zero.

Predicate testing whether the int64 argument is lower than or equal to zero.

Predicate testing whether the nativeint argument is lower than or equal to zero.

is_none ~msg:m x raises Failed if x is different from None.

Predicate testing whether the option argument is equal to None.

Predicate testing whether the array argument is not empty.

Predicate testing whether the list argument is not empty.

Predicate testing whether the string argument is not empty.

Predicate testing whether the float argument is different from nan.

Predicate testing whether the float argument is different from zero.

Predicate testing whether the float argument is different from zero.

Predicate testing whether the int argument is different from zero.

Predicate testing whether the int32 argument is different from zero.

Predicate testing whether the int64 argument is different from zero.

Predicate testing whether the nativeint argument is different from zero.

Predicate testing whether the int argument is odd.

Predicate testing whether the int32 argument is odd.

Predicate testing whether the int64 argument is odd.

Predicate testing whether the nativeint argument is odd.

Predicate testing whether the float argument is greater than or equal to zero.

Predicate testing whether the int argument is greater than or equal to zero.

Predicate testing whether the int32 argument is greater than or equal to zero.

Predicate testing whether the int64 argument is greater than or equal to zero.

Predicate testing whether the nativeint argument is greater than or equal to zero.

Equivalent to Filename.is_relative.

is_result p returns a predicate that ensures that the outcome is a result satisfying predicate p.

is_some ~msg:m x raises Failed if x is equal to None.

Predicate testing whether the option argument is different from None.

Predicate testing whether the char argument is either a bare space or a tabulation.

is_true ~msg:m x raises Failed if x is false.

Predicate testing whether the float argument is equal to zero.

Predicate testing whether the float argument is equal to zero.

Predicate testing whether the int argument is equal to zero.

Predicate testing whether the int32 argument is equal to zero.

Predicate testing whether the int64 argument is equal to zero.

Predicate testing whether the nativeint argument is equal to zero.

iter f e applies f to the elements of e.

iter_list f l applies f to the elements of l.

Equivalent to run_tests, except that the list of tests to be run is composed of all the tests build by the add_xyz functions of this module.

Generator for char values representing letters.

lift e s constructs a generator that always returns e, s is the string representation of e.

lift e s constructs an enumerator that only returns e, s is the string representation of e.

lift_array a p constructs an enumerator that returns the elements from a, using p to convert elements into their string representation.

lift_list l p constructs an enumerator that returns the elements from l, using p to convert elements into their string representation.

lift_string s constructs an enumerator that returns the characters from s.

Reducer for list values.

list l e constructs a generator for lists.

list e l constructs an enumerator for lists of length l, e is used to generate the list elements.

Constructs a predicate that is the conjunction of the passed ones.

Constructs a predicate that is the conjunction of the passed ones.

Constructs a predicate that is the disjunction of the passed ones.

Constructs a predicate that is the disjunction of the passed ones.

Constructs a predicate that is the exclusive disjunction of the passed ones.

Constructs a predicate that is the exclusive disjunction of the passed ones.

ls ~options:options l builds a command listing elements from l, passing options to the ls executable.

make_assert_test ~title:t set_up f tear_down constructs a test running the function f.

make_bool w1 w2 constructs a generator for bool values.

make_char x y constructs an enumerator for char values between x and y (both inclusive).

make_enum_test ~title:t e f spec constructs an enumerator-based test f is the function to be tested against the values enumerated by e, ensuring that the specification spec is satisfied (cf.

make_equal eq prn returns a function for testing equality of maps.

make_equal e p is equivalent to equal ~eq:e ~prn:p.

make_equal_array eq prn returns a function for testing equality of arrays.

make_equal_hashtbl eq prn prn' returns a function for testing equality of hash tables.

make_equal_list eq prn returns a function for testing equality of list.

make_equal_queue eq prn returns a function for testing equality of queues.

make_equal_stack eq prn returns a function for testing equality of stacks.

make_equal_weak eq prn returns a function for testing equality of weak arrays.

make_float f g constructs a generator for float values.

make_int m n constructs a generator for int values.

make_int32 m n constructs a generator for int32 values.

make_int64 m n constructs a generator for int64 values.

make_nativeint m n constructs a generator for nativeint values.

make_not_equal eq prn returns a function for testing inequality of maps.

make_not_equal e p is equivalent to not_equal ~eq:e ~prn:p.

make_not_equal_array eq prn returns a function for testing inequality of arrays.

make_not_equal_hashtbl eq prn prn' returns a function for testing inequality of hash tables.

make_not_equal_list eq prn returns a function for testing inequality of lists.

make_not_equal_queue eq prn returns a function for testing inequality of queues.

make_not_equal_stack eq prn returns a function for testing inequality of stacks.

make_not_equal_weak eq prn returns a function for testing inequality of weak arrays.

Equivalent to make_enum_test for partial functions.

Equivalent to make_random_test for partial functions.

make_raises eq p ~msg:m f raises Failed if f () evaluates without raising an exception e that makes eq e evaluates to true.

Creates a new random source.

Creates a new random source, using the passed value as the seed.

Creates a new random source, using the passed value as the seed.

make_random_test ~title:t ~nb_runs:nb ~nb_tries:nt ~classifier:c ~reducer:red ~random_src:rnd gen f spec constructs a random test.

make_shell_test ~title:t l constructs a test running the commands from l using Shell.run_list.

make_simple_test ~title:t f constructs a test running the function f.

Converts an array into a string, the passed function being used to convert array elements.

Converts a hash table into a string, the passed functions being used to convert table keys and values.

Converts a list into a string, the passed function being used to convert list elements.

Converts an option into a string, the passed function being used to convert the embedded element (if any).

Converts a queue into a string, the passed function being used to convert queue elements.

Converts a reference into a string, the passed function being used to convert the embedded element.

Converts a stack into a string, the passed function being used to convert stack elements.

The identity function.

Converts a couple into a string, the passed functions being used to convert the various components.

Converts a triple into a string, the passed functions being used to convert the various components.

Converts a quadruple into a string, the passed functions being used to convert the various components.

Converts a quintuple into a string, the passed functions being used to convert the various components.

Converts a weak array into a string, the passed function being used to convert array elements.

map1 f p g constructs a generator applying the function f to the values generated by g.

map1 f p e constructs an enumerator applying the function f to the values enumerated by e.

map2 f p (g1, g2) constructs a generator applying the function f to the values generated by g1 and g2.

map2 f p (e1, e2) constructs an enumerator applying the function f to the values enumerated by e1 and e2.

map3 f p (g1, g2, g3) constructs a generator applying the function f to the values generated by g1, g2 and g3.

map3 f p (e1, e2, e3) constructs an enumerator applying the function f to the values enumerated by e1, e2, and e3.

map4 f p (g1, g2, g3, g4) constructs a generator applying the function f to the values generated by g1, g2, g3 and g4.

map4 f p (e1, e2, e3, e4) constructs an enumerator applying the function f to the values enumerated by e1, e2, e3, and e4.

map5 f p (g1, g2, g3, g4, g5) constructs a generator applying the function f to the values generated by g1, g2, g3, g4 and g5.

map5 f p (e1, e2, e3, e4, e5) constructs an enumerator applying the function f to the values enumerated by e1, e2, e3, e4, and e5.

mkdir ~options:options path builds a command creating the directory path, passing options to the mkdir executable.

mv ~options:options l d builds a command moving elements from l to d, passing options to the mv executable.

Reducer for nativeint values.

Generator for nativeint values.

nativeint x y constructs an enumerator for nativeint values between x and y (both inclusive).

Generator for negative int values.

Generator for negative int32 values.

Generator for negative int64 values.

Generator for negative nativeint values.

Predicate that always evaluates to false.

no_raise ~msg:m f raises Failed if f () raises an exception.

Constructs a predicate that is the negation of the passed one.

Same as not_equal, but specialized for set values.

not_equal ~eq:e ~prn:p ~msg:m x y raises Failed if x and y are equal, relatively to the equality function e.

Same as not_equal, but specialized for bool values.

Same as not_equal, but specialized for char values.

Same as not_equal, but specialized for Complex.t values.

Same as not_equal, but specialized for float values.

Same as not_equal, but specialized for int values.

Same as not_equal, but specialized for int32 values.

Same as not_equal, but specialized for int64 values.

Same as not_equal, but specialized for nativeint values.

Same as not_equal, but specialized for string values.

Same as not_equal, but based on physical equality.

number n constructs a generator for string values representing numbers.

number_bin n constructs a generator for string values representing numbers.

number_hex n constructs a generator for string values representing numbers.

number_oct n constructs a generator for string values representing numbers.

Reducer for option values.

option b e constructs a generator for option values.

option e constructs an enumerator for option values.

Actual predicate over p values.

Equivalent to Filename.parent_dir_name.

pipe c1 c2 builds a command that is equivalent to c1 piped to c2.

Changes the current directory to the value poped from the directory stack, and returns it.

Generator for positive int values.

Generator for positive int32 values.

Generator for positive int64 values.

Generator for positive nativeint values.

Pushes the current directory to the directory stack, then changes the current directory to the value of the passed argument.

Returns the current directory.

Equivalent to pwd, as a command.

Reducer for Queue.t values.

queue s e constructs a generator for Queue.t values.

queue e l constructs an enumerator for queues of length l, e is used to generate the queue elements.

Equivalent to Filename.quote.

raises ~msg:m f raises Failed if f () evaluates without raising an exception.

read_lines file returns the lines from file file.

redirect_append c f builds a command that redirect the output of command c to file f in append mode.

redirect_error c f builds a command that redirect the error of command c to file f in append mode.

redirect_error c f builds a command that redirect the error of command c to file f.

redirect_output c f builds a command that redirect the output of command c to file f.

ref e constructs a generator for reference values.

ref e constructs an enumerator for reference values.

return x returns the function always returning x.

rm ~options:options l builds a command deleting elements from l, passing options to the rm executable.

rmdir ~options:options path builds a command deleting the directory path, passing options to the rmdir executable.

run c runs the command c, returning its exit code.

Runs the passed test, printing result according to passed output mode (by default bare text on the standard output).

Runs the passed test list, printing result according to passed output mode (by default bare text on the standard output).

Same as equal, but based on physical equality.

sed ~options:options x builds a command applying the expression x to input, passing options to the sed executable.

select_array a f constructs a generator that returns an element of a.

select_array_weighted a f constructs a generator that returns an element of a.

select_list l f constructs a generator that returns an element of l.

select_list_weighted l f constructs a generator that returns an element of l.

sequence l constructs an enumerator that is the concatenation of the enumerators of l.

set_configuration c changes the configuration to c.

sleep x suspends the execution for x seconds.

sed ~options:options l builds a command sorting the data it receives, passing options to the sort executable.

Reducer for Stack.t values.

stack s e constructs a generator for Stack.t values.

stack e l constructs an enumerator for stacks of length l, e is used to generate the stack elements.

Reducer for string values.

string i c constructs a generator for string values.

string ch len constructs an enumerator for string values of length len, using ch to generate the characters.

Converts a buffer into an escaped string.

Converts a character into an escaped string, for display.

Converts a complex into a string.

Converts a string into an escaped string, for display.

Always returns "()".

strings sep i s constructs a generator for string values.

Equivalent to Filename.temp_file.

Conversion function into strings.

Returns how many times the function f has been called.

touch ~options:options l builds a command touching elements from l, passing options to the touch executable.

transform f g constructs a generator applying the function f to the values generated by g.

transform f e constructs an enumerator applying the function f to the values enumerated by e.

tuple_apply1 f x is equivalent to f x.

tuple_apply2 f x y is equivalent to f (x, y).

tuple_apply3 f x y z is equivalent to f (x, y, z).

tuple_apply4 f x y z t is equivalent to f (x, y, z, t).

tuple_apply5 f x y z t u is equivalent to f (x, y, z, t, u).

Reducer for unit values.

Dummy generator for unit value.

Dummy enumerator for unit value.

The current version of Kaputt as a string.

Reducer for Weak.t values.

weak s e constructs a generator for Weak.t values.

array e l constructs an enumerator for weak arrays of length l, e is used to generate the array elements.

word n constructs a generator for string values representing words.

words n p constructs a generator for string values representing sequences of words.

write_lines l file writes the strings from l to file file, a '\n' character being written after each string.

Identity function.

The identity function.

The identity function.

zip2 p1 p2 zips p1 and p2 into a predicate over couples.

zip2 g1 g2 zips g1 and g2 into a generator producing couple values.

zip2 e1 e2 zips e1 and e2 into an enumerator producing couple values.

zip3 p1 p2 p3 zips p1, p2 and p3 into a predicate over triples.

zip3 g1 g2 g3 zips g1, g2 and g3 into a generator producing triple values.

zip3 e1 e2 e3 zips e1, e2 and e3 into an enumerator producing triple values.

zip4 p1 p2 p3 p4 zips p1, p2, p3 and p4 into a predicate over quadruples.

zip4 g1 g2 g3 g4 zips g1, g2, g3 and g4 into a generator producing quadruple values.

zip4 e1 e2 e3 e4 zips e1, e2, e3 and e4 into an enumerator producing quadruple values.

zip5 p1 p2 p3 p4 p5 zips p1, p2, p3, p4 and p5 into a predicate over quintuples.

zip5 g1 g2 g3 g4 g5 zips g1, g2, g3, g4 and g5 into a generator producing quintuple values.

zip5 e1 e2 e3 e4 e5 zips e1, e2, e3, e4 and e5 into an enumerator producing quintuple values.