Module QCheck.Gen Source The Gen module offers combinators to build custom generators. Unlike the the 'a arbitrary record type , which comes with printers, shrinkers, etc. Gen.t
A random generator for values of type 'a.
Random generator with a size bound.
Create a constant generator.
Source val bind : 'a t -> ('a -> 'b t -> 'b t Monadic bind for writing dependent generators. First generates an 'a and then passes it to the given function, to generate a 'b.
Source val (>>=) : 'a t -> ('a -> 'b t -> 'b t Synonym for bind
Applicative operator for composing a function generator and an argument generator into a result generator.
Source val (<*>) : ('a -> 'b ) t -> 'a t -> 'b t Synonym for ap
Source val map : ('a -> 'b ) -> 'a t -> 'b t map f g transforms a generator g by applying f to each generated element.
Source val map2 : ('a -> 'b -> 'c ) -> 'a t -> 'b t -> 'c t map2 f g1 g2 transforms two generators g1 and g2 by applying f to each pair of generated elements.
Source val map3 : ('a -> 'b -> 'c -> 'd ) -> 'a t -> 'b t -> 'c t -> 'd t map3 f g1 g2 g3 transforms three generators g1, g2, and g3 by applying f to each triple of generated elements.
Source val map4 : ('a -> 'b -> 'c -> 'd -> 'e ) -> 'a t -> 'b t -> 'c t -> 'd t -> 'e t map4 f g1 g2 g3 g4 transforms four generators g1, g2, g3, and g4 by applying f to each quadruple of generated elements.
Source val map5 :
('a -> 'b -> 'c -> 'd -> 'e -> 'f ) -> 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t map5 f g1 g2 g3 g4 g5 transforms five generators g1, g2, g3, g4, and g5 by applying f to each quintuple of generated elements.
map_keep_input f g transforms a generator g by applying f to each generated element. Returns both the generated element from g and the output from f.
Source val (>|=) : 'a t -> ('a -> 'b ) -> 'b t An infix synonym for map
Source val (<$>) : ('a -> 'b ) -> 'a t -> 'b t Constructs a generator that selects among a given list of generators.
Source val oneof_list : 'a list-> 'a t Constructs a generator that selects among a given list of values.
Constructs a generator that selects among a given list of values.
Source val oneof_array : 'a array-> 'a t Constructs a generator that selects among a given array of values.
Source val oneofa : 'a array-> 'a t Constructs a generator that selects among a given array of values.
Source val oneof_weighted : (int * 'a t list-> 'a t Constructs a generator that selects among a given list of generators. Each of the given generators are chosen based on a positive integer weight.
Source val frequency : (int * 'a t list-> 'a t Constructs a generator that selects among a given list of generators. Each of the given generators are chosen based on a positive integer weight.
Source val oneof_list_weighted : (int * 'a ) list-> 'a t Constructs a generator that selects among a given list of values. Each of the given values are chosen based on a positive integer weight.
Source val frequencyl : (int * 'a ) list-> 'a t Constructs a generator that selects among a given list of values. Each of the given values are chosen based on a positive integer weight.
Source val oneof_array_weighted : (int * 'a ) array-> 'a t Constructs a generator that selects among a given array of values. Each of the array entries are chosen based on a positive integer weight.
Source val frequencya : (int * 'a ) array-> 'a t Constructs a generator that selects among a given array of values. Each of the array entries are chosen based on a positive integer weight.
Source val shuffle_array : 'a array-> 'a arrayt Creates a generator of shuffled arrays.
Source val shuffle_a : 'a array-> unit t Shuffles the array in place.
Source val shuffle_list : 'a list-> 'a listt Creates a generator of shuffled lists.
Source val shuffle_l : 'a list-> 'a listt Creates a generator of shuffled lists.
Source val shuffle_list_weighted : (int * 'a ) list-> 'a listt Creates a generator of weighted shuffled lists. A given list is shuffled on each generation according to the weights of its elements. An element with a larger weight is more likely to be at the front of the list than an element with a smaller weight. If we want to pick random elements from the (head of) list but need to prioritize some elements over others, this generator can be useful.
Example: given a weighted list [1, "one"; 5, "five"; 10, "ten"], the generator is more likely to generate ["ten"; "five"; "one"] or ["five"; "ten"; "one"] than ["one"; "ten"; "five"] because "ten" and "five" have larger weights than "one".
Source val shuffle_w_l : (int * 'a ) list-> 'a listt Source val range_subset : size :int -> int -> int -> int array t range_subset ~size:k low high generates an array of length k of sorted distinct integers in the range low..high (included).
Complexity O(k log k), drawing k random integers.
Source val array_subset : int -> 'a array-> 'a arrayt array_subset k arr generates a sub-array of k elements at distinct positions in the input array arr, in the same order.
Complexity O(k log k), drawing k random integers.
Generates floating point numbers.
Generates positive floating point numbers (0. included).
Generates negative floating point numbers (-0. included).
Generates positive floating point numbers (0. included).
Generates negative floating point numbers (-0. included).
Source val float_bound_inclusive : float -> float t float_bound_inclusive bound returns a random floating-point number between 0 and bound (inclusive). If bound is negative, the result is negative or zero. If bound is 0, the result is 0.
Source val float_bound_exclusive : float -> float t float_bound_exclusive bound returns a random floating-point number between 0 and bound (exclusive). If bound is negative, the result is negative or zero.
Source val float_range : float -> float -> float t float_range low high generates floating-point numbers within low and high (inclusive)
Source val (--.) : float -> float -> float t Source val float_exp : float -> float t float_exp m generates floating-point numbers following an exponential distribution with a mean of m.
Source val exponential : float -> float t Generates small natural numbers.
Generates small natural numbers. Synonym for nat
Generates natural numbers, possibly large.
Generates strictly negative integers uniformly (0 excluded).
Generates non-strictly negative integers (0 included).
Generates non-strictly positive integers uniformly (0 included).
Generates non-strictly positive integers uniformly (0 included).
Generates integers uniformly.
Generated small signed integers.
Small UNSIGNED integers, for retrocompatibility.
Uniform integer generator producing integers between 0 and bound (inclusive). For bound < 2^{30} - 1 uses Random.State.int for integer generation.
Source val int_range : int -> int -> int t Uniform integer generator producing integers within low,high (inclusive).
Source val graft_corners : 'a t -> 'a list-> unit -> 'a t graft_corners gen l () makes a new generator that enumerates the corner cases in l and then behaves like g.
Note that graft_corners gen l () is stateful, meaning that once the elements of l have been emitted, subsequent calls will not reproduce them. It is therefore recommended that separate tests each use a fresh generator.
Source val int_pos_corners : int list Non-negative corner cases for int.
Source val int_corners : int list All corner cases for int.
Source val int_small_corners : unit -> int t As int_small, but each newly created generator starts with a list of corner cases before falling back on random generation.
Note that int_small_corners () is stateful, meaning that once the list of corner cases has been emitted, subsequent calls will not reproduce them.
Source val (--) : int -> int -> int t Generates int32 values uniformly.
Generates int64 values uniformly.
Builds a list generator from an element generator. List size is generated by nat
Source val list_size : int t -> 'a t -> 'a listt Builds a list generator from a (non-negative) size generator and an element generator.
Source val list_repeat : int -> 'a t -> 'a listt list_repeat i g builds a list generator from exactly i elements generated by g.
Builds an array generator from an element generator. Array size is generated by nat
Source val array_size : int t -> 'a t -> 'a arrayt Builds an array generator from a (non-negative) size generator and an element generator.
Source val array_repeat : int -> 'a t -> 'a arrayt array_repeat i g builds an array generator from exactly i elements generated by g.
Source val option : ?ratio :float -> 'a t -> 'a optiont An option generator, with optional ratio.
Source val opt : ?ratio :float -> 'a t -> 'a optiont opt is an alias of option
A result generator, with optional ratio.
Generates characters upto character code 255.
Generates printable ascii characters - either '\n' or in the range 32 to 126, inclusive.
Generates numeral characters uniformly distributed over '0'..'9'.
Source val char_range : char -> char -> char t Generates chars between the two bounds, inclusive. Example: char_range 'a' 'z' for all lower case ascii letters.
Source val bytes_size : ?gen :char t -> int t -> bytes t Builds a bytes generator from a (non-negative) size generator. Accepts an optional character generator (the default is char
Source val bytes_size_of : int t -> char t -> bytes t Builds a bytes generator from a (non-negative) size generator and a character generator.
Builds a bytes generator. Bytes size is generated by natchar
Note: This had an optional ?gen parameter removed in 0.90. Use bytes_ofchar generator.
Builds a bytes generator using the given character generator.
Source val bytes_printable : bytes t Generator using the printable
Builds a bytes generator using the charnat_small
Source val bytes_small_of : char t -> bytes t Builds a bytes generator using the given character generator, length is nat_small
Source val string_size : ?gen :char t -> int t -> string t Builds a string generator from a (non-negative) size generator. Accepts an optional character generator (the default is char
Source val string_size_of : int t -> char t -> string t Builds a string generator from a (non-negative) size generator and a character generator.
Builds a string generator. String size is generated by natchar
Note: This had an optional ?gen parameter removed in 0.90. Use string_ofchar generator.
Source val string_of : char t -> string t Builds a string generator using the given character generator.
Source val string_readable : string t Builds a string generator using the printable
Source val string_printable : string t Builds a string generator using the printable
Source val small_string : ?gen :char t -> string t Builds a string generator, length is nat_smallchar
Builds a string generator using the charnat_small
Source val string_small_of : char t -> string t Builds a string generator using the given character generator, length is nat_small
Source val list_small : 'a t -> 'a listt Generates lists of small size (see nat_small
Source val small_list : 'a t -> 'a listt Generates lists of small size (see nat_small
Source val flatten_list : 'a t -> 'a listt Generate a list of elements from individual generators
Source val flatten_l : 'a t -> 'a listt Generate a list of elements from individual generators
Source val flatten_array : 'a t -> 'a arrayt Generate an array of elements from individual generators
Source val flatten_a : 'a t -> 'a arrayt Generate an array of elements from individual generators
Source val flatten_option : 'a t -> 'a optiont Generate an option from an optional generator
Source val flatten_opt : 'a t -> 'a optiont Generate an option from an optional generator
Generate a result from Ok g, an error from Error e
Generate a result from Ok g, an error from Error e
Source val array_small : 'a t -> 'a arrayt Generates arrays of small size (see nat_small
Source val small_array : 'a t -> 'a arrayt Generates arrays of small size (see nat_small
Create tuple generators by composing individual element generators. For example, Gen.(tup3 int char bool) creates a (int * char * bool) triple generator by composing the int, char, and bool generators.
Source val triple : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c ) t Source val quad : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd ) t Combines two generators into a 2-tuple generator.
Source val tup3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c ) t Combines three generators into a 3-tuple generator.
Source val tup4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd ) t Combines four generators into a 4-tuple generator.
Source val tup5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e ) t Combines five generators into a 5-tuple generator.
Source val tup6 :
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> ('a * 'b * 'c * 'd * 'e * 'f ) t Combines six generators into a 6-tuple generator.
Source val tup7 :
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g ) t Combines seven generators into a 7-tuple generator.
Source val tup8 :
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> 'h t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h ) t Combines eight generators into an 8-tuple generator.
Source val tup9 :
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> 'h t -> 'i t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i ) t Combines nine generators into a 9-tuple generator.
Collapses a generator of generators to simply a generator.
Creates a generator from a size-bounded generator by first generating a size using nat
Creates a generator from a size-bounded generator by first generating a size using the integer generator and passing the result to the size-bounded generator.
Source val fix : (('a -> 'b t -> 'a -> 'b t -> 'a -> 'b t Parametrized fixpoint combinator for generating recursive values.
The fixpoint is parametrized over an arbitrary state ('a), and the fixpoint computation may change the value of this state in the recursive calls.
In particular, this can be used for size-bounded generators ('a is int). The passed size-parameter should decrease to ensure termination.
Example:
type tree = Leaf of int | Node of tree * tree
let leaf x = Leaf x
let node x y = Node (x,y)
let g = QCheck.Gen.(sized @@ fix
(fun self n -> match n with
| 0 -> map leaf nat
| n ->
oneof_weighted
[1, map leaf nat;
2, map2 node (self (n/2)) (self (n/2))]
))
Source val nat_split2 : int -> (int * int) t nat_split2 n generates pairs (n1, n2) of natural numbers with n1 + n2 = n.
This is useful to split sizes to combine sized generators.
Source val pos_split2 : int -> (int * int) t pos_split2 n generates pairs (n1, n2) of strictly positive (nonzero) natural numbers with n1 + n2 = n.
This is useful to split sizes to combine sized generators.
Source val nat_split : size :int -> int -> int array t nat_split ~size:k n generates k-sized arrays n1,n2,..nk of natural numbers in [0;n] with n1 + n2 + ... + nk = n.
This is useful to split sizes to combine sized generators.
Complexity O(k log k).
Source val pos_split : size :int -> int -> int array t pos_split ~size:k n generates k-sized arrays n1,n2,..nk of strictly positive (non-zero) natural numbers with n1 + n2 + ... + nk = n.
This is useful to split sizes to combine sized generators.
Complexity O(k log k).
Source val delay : (unit -> 'a t -> 'a t Delay execution of some code until the generator is actually called. This can be used to manually implement recursion or control flow in a generator.
Source val (let+) : 'a t -> ('a -> 'b ) -> 'b t Source val (and+) : 'a t -> 'b t -> ('a * 'b ) t Source val (let*) : 'a t -> ('a -> 'b t -> 'b t Source val (and*) : 'a t -> 'b t -> ('a * 'b ) t These functions should not be used in tests: they are provided for convenience to debug/investigate what values a generator produces.
generate ~n g generates n instances of g.
generate1 g generates one instance of g.