Snap (b0.B0_testing.Snap)

module T = Test.T

Repeated here for convenience, e.g. Snap.(list T.int).

Exceptions

val exn : exn Test.snap

exn is Test.snap Test.T.snap.

val raise : 
  ?ret:'a Test.T.t ->
  ?exn:exn Test.T.t ->
  ?diff:exn Test.Diff.t ->
  ?__POS__:Test.loc ->
  (unit -> 'a) ->
  exn Test.Snapshot.t ->
  unit

raise f snapshots the exception raised by f by printing it using exn (defaults to Exceptions). The combinators fails if no exception is raised by f.

Base types

val unit : unit Test.snap

unit is Test.snap Test.T.unit.

val bool : bool Test.snap

bool is Test.snap Test.T.bool.

val int : int Test.snap

int is Test.snap Test.T.int. Warning. Depending on their magnitude integer snapshots may not be portable across 64-bit and 32-bit platforms.

val int32 : int32 Test.snap

int32 is Test.snap Test.T.int32

val uint32 : int32 Test.snap

uint32 is Test.snap Test.T.uint32

val int64 : int64 Test.snap

int64 is Test.snap Test.T.int64

val uint64 : int64 Test.snap

uint64 is Test.snap Test.T.uint64

val nativeint : nativeint Test.snap

nativeint is Test.snap Test.T.nativeint

val nativeuint : nativeint Test.snap

nativeuint is Test.snap Test.T.nativeuint

val float : float Test.snap

float is Test.snap Test.T.float. N.B. not exactly.

val hex_float : float Test.snap

hex_float is Test.snap Test.T.hex_float N.B. not exactly.

Character and strings

Note. The string snapshoters have a special substitution function that respects quoted literals.

val char : char Test.snap

char is Test.snap Test.T.char.

val ascii_string : string Test.snap

val string : string Test.snap

val line : string Test.snap

like string but on a single line.

val lines : string Test.snap

lines uses Test.T.lines to produce the diffs.

Parametric types

val option : 'a Test.T.t -> 'a option Test.snap

option t snapshots t option.

val either : 'a Test.T.t -> 'b Test.T.t -> ('a, 'b) Either.t Test.snap

result left right is Test.snap (Test.T.either left right)

val result : 'a Test.T.t -> ('a, string) Stdlib.result Test.snap

result ok is Test.snap (Test.T.result ok)

val result' : 'a Test.T.t -> 'e Test.T.t -> ('a, 'e) Stdlib.result Test.snap

result ok error is Test.snap (Test.T.result ok error)

val list : 'a Test.T.t -> 'a list Test.snap

list elt is Test.snap (Test.T.list elt)

val array : 'a Test.T.t -> 'a array Test.snap

array elt is Test.snap (Test.T.array elt)

val pair : 'a Test.T.t -> 'b Test.T.t -> ('a * 'b) Test.snap

pair fst snd is Test.snap (Test.T.pair fst snd)

val t2 : 'a Test.T.t -> 'b Test.T.t -> ('a * 'b) Test.snap

t2 is pair.

val t3 : 'a Test.T.t -> 'b Test.T.t -> 'c Test.T.t -> ('a * 'b * 'c) Test.snap

t3 v0 v1 v2 is Test.snap for triplets.

val t4 : 
  'a Test.T.t ->
  'b Test.T.t ->
  'c Test.T.t ->
  'd Test.T.t ->
  ('a * 'b * 'c * 'd) Test.snap

t4 is Test.snap for quadruplets.

val t5 : 
  'a Test.T.t ->
  'b Test.T.t ->
  'c Test.T.t ->
  'd Test.T.t ->
  'e Test.T.t ->
  ('a * 'b * 'c * 'd * 'e) Test.snap

t5 is Test.snap for quintuplets.

val t6 : 
  'a Test.T.t ->
  'b Test.T.t ->
  'c Test.T.t ->
  'd Test.T.t ->
  'e Test.T.t ->
  'f Test.T.t ->
  ('a * 'b * 'c * 'd * 'e * 'f) Test.snap

t6 is Test.snap for sextuplets.

Command executions

val stdout : 
  ?__POS__:Test.loc ->
  ?diff:string Test.Diff.t ->
  ?env:B0_std.Os.Env.assignments ->
  ?cwd:B0_std.Fpath.t ->
  ?stdin:B0_std.Os.Cmd.stdi ->
  ?stderr:[ `Stdo of B0_std.Os.Cmd.stdo | `Out ] ->
  trim:bool ->
  B0_std.Cmd.t ->
  string Test.Snapshot.t ->
  unit

stdout cmd snaphosts the standard output of the execution (see Os.run_status_out). The function Test.fails if there's any sort of error. The status is ignored (FIXME do something more sensitive we could assert it)).