package expect_test_helpers_kernel

hide_positions_in_string does line-based regexp matching to replace line numbers and column numbers that appear in source-code positions with constant text LINE and COL. This can be useful in making displayed test output less fragile.

Renders an s-expression as a string. With ~hide_positions:true, patterns in the string that match OCaml-style file positions are modified to hide the line number, column number, and character positions, to make output less fragile.

For printing an s-expression to stdout. hide_positions works as in sexp_to_string.

print_and_check_stable_type prints the bin-io digest for the given type, and the bin-io and sexp serializations of the given values. Prints an error message for any serializations that fail to round-trip, and for any bin-io serializations that exceed max_binable_length.

print_and_check_stable_int63able_type works like print_and_check_stable_type, and includes Int63.t serializations.

print_bin_ios prints the shape digest of a Binable type, and the bin-io serialization of example values. print_bin_ios is used to write expect tests that can detect if the serialization format of a stable type changes.

print_bin_ios_with_max is like print_bin_ios, except it causes a CR to be printed (using require) if any serializations are longer than the supplied max_binable_length. This is useful for ensuring that serializations fit in some required size, e.g. an ethernet MTU.

print_cr here message prints a CR require-failed, which will appear in expect-test output. The CR will appear in the feature owner's fe todo, thus preventing release of the feature. print_cr is an expect-test-friendly version of assert false. It works with the normal expect-test workflow because it does not raise, and it prevents mistakenly releasing features that violate a required property. There is no need to 'X' a CR require-failed; simply fix the property that triggered the print_cr and re-run the test to restore the empty output.

require here bool is a no-op if bool = true, but if not, prints a CR require-failed similarly to print_cr, with a message determined by the if_false_then_print_s argument, if any.

if_false_then_print_s is useful for including information that may help debug the problem, but that would otherwise be too voluminous. if_false_then_print_s is lazy to avoid construction of the sexp except when needed.

require_equal compares its two arguments using the equality predicate of the provided module. If the comparison fails, prints a message that renders the arguments as sexps.

Like require_equal, but derives an equality predicate from a comparison function.

Like require_equal, but when equality fails produces a message including sexps of both Set.diff first second and Set.diff second first to aid in debugging.

show_raise calls f () and prints the exception that it raises, or, if it doesn't raise, prints did not raise. show_raise ignores the result of f so that one doesn't have to put an ignore inside the body of an f that is expected to raise. ~hide_positions:true operates as in print_s, to make output less fragile. Using ~show_backtrace:true will result in a CR in the expectation, but it's still available here as it is still valuable when initially writing tests and debugging.

require_does_not_raise is like show_raise, but does not print anything if the function does not raise, and prints a CR along with the exception if it does raise. Unlike for show_raise, the supplied function is required to return unit to avoid mistakes like incomplete partial application that silently would not raise, but for the wrong reason.

require_does_raise is like show_raise, but additionally prints a CR if the function does not raise.

require_allocation_does_not_exceed is a specialized form of require that only produces output when f () allocates more than the given limits. The output will include the actual number of major and minor words allocated. We do NOT include these numbers in the successful case because those numbers are not stable with respect to compiler versions and build flags.

If f returns a value that should be ignored, use this idiom:

ignore (show_allocation f : t)

rather than this idiom:

show_allocation (fun () -> ignore (f () : t))

With the latter idiom, the compiler may optimize the computation of f () taking advantage of the fact that the result is ignored, and eliminate allocation that is intended to be measured. With the former idiom, the compiler cannot do such optimization and must compute the result of f ().

require_no_allocation here f is equivalent to require_allocation_does_not_exceed (Minor_words 0) here f.

print_and_check_container_sexps prints the sexp representation of maps, sets, hash tables, and hash sets based on the given values. For sets and hash sets, prints a CR if the sexp does not correspond to a list of elements. For maps and hash tables, prints a CR if the sexp does not correspond to an association list keyed on elements.

print_and_check_comparable_sexps is like print_and_check_container_sexps for maps and sets only.

print_and_check_hashable_sexps is like print_and_check_container_sexps for hash tables and hash sets only.

quickcheck is similar to Quickcheck.test. It stops after the first iteration that prints a CR, as detected by on_print_cr.

on_print_cr determines the behavior of all functions above that print CRs, such as print_cr and require. The rendered string form of the CR is passed to !on_print_cr. The default value is print_endline; this can be overridden to replace or extend the default behavior. For example, some testing harnesses may choose to abort a series of tests after the first CR is printed.

We export Expect_test_config to override Expect_test_config.run f so that, if f () raises, run prints the exception rather than raising. Printing works better with the expect-test workflow than an unhandled exception, because there is a .corrected file that one can accept and inspect.