module Gen: sig .. end
Generate Random Values
type 'a t = Random.State.t -> 'a
A random generator for values of type 'a
type 'a sized = int -> Random.State.t -> 'a
Random generator with a size bound
val return : 'a -> 'a t
Create a constant generator
val (>>=) : '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.
val (<*>) : ('a -> 'b) t -> 'a t -> 'b t
Infix operator for composing a function generator and an argument generator
into a result generator
val map : ('a -> 'b) -> 'a t -> 'b t
map f g transforms a generator g by applying f to each generated element
val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
map f g1 g2 transforms two generators g1 and g2 by applying f to each
pair of generated elements
val map3 : ('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
map f g1 g2 g3 transforms two generators g1, g2, and g3 by applying f
to each triple of generated elements
val map_keep_input : ('a -> 'b) -> 'a t -> ('a * 'b) t
map f g transforms a generator g by applying f to each generated element.
Returns both the generated elememt from g and the output from f.
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val oneof : 'a t list -> 'a t
Constructs a generator that selects among a given list of generators
val oneofl : 'a list -> 'a t
Constructs a generator that selects among a given list of values
val oneofa : 'a array -> 'a t
Constructs a generator that selects among a given array of values
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.
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.
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.
val shuffle_a : 'a array -> unit t
Shuffle the array in place
val shuffle_l : 'a list -> 'a list t
Creates a generator of shuffled lists
val unit : unit t
The unit generator
val bool : bool t
The Boolean generator
val float : float t
Generates floating point numbers
val pfloat : float t
Generates positive floating point numbers
val nfloat : float t
Generates negative floating point numbers
val nat : int t
Generates small natural numbers
val neg_int : int t
Generates negative integers
val pint : int t
Generates positive integers uniformly
val int : int t
Generates integers uniformly
val small_nat : int t
val small_int : int t
val int_bound : int -> int t
Uniform integer generator producing integers within 0... bound.
Raises Invalid_argument if the bound is too high (typically 2^30)
val int_range : int -> int -> int t
Uniform integer generator producing integers within low,high
Raises Invalid_argument if the range is too large (typically 2^30)
val (--) : int -> int -> int t
val ui32 : int32 t
Generates (unsigned) int32 values
val ui64 : int64 t
Generates (unsigned) int64 values
val list : 'a t -> 'a list t
Builds a list generator from an element generator. List size is generated by
QCheck.Gen.nat
val list_size : int t -> 'a t -> 'a list t
Builds a list generator from a (non-negative) size generator and an element generator
val list_repeat : int -> 'a t -> 'a list t
list_repeat i g builds a list generator from exactly i elements generated by g
val array : 'a t -> 'a array t
Builds an array generator from an element generator. Array size is generated by
QCheck.Gen.nat
val array_size : int t -> 'a t -> 'a array t
Builds an array generator from a (non-negative) size generator and an element generator
val array_repeat : int -> 'a t -> 'a array t
array_repeat i g builds an array generator from exactly i elements generated by g
val opt : 'a t -> 'a option t
An option generator
val pair : 'a t -> 'b t -> ('a * 'b) t
Generates pairs
val triple : 'a t ->
'b t -> 'c t -> ('a * 'b * 'c) t
Generates triples
val quad : 'a t ->
'b t ->
'c t -> 'd t -> ('a * 'b * 'c * 'd) t
Generates quadruples
Since 0.5.1
val char : char t
Generates characters upto character code 255
val printable : char t
Generates printable characters
val numeral : char t
Generates numeral characters
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
QCheck.Gen.char)
val string : ?gen:char t -> string t
val small_string : ?gen:char t -> string t
Builds a string generator. String size is in the range
0-10.
Accepts an optional character generator (the default is
QCheck.Gen.char)
val join : 'a t t -> 'a t
Collapses a generator of generators to simply a generator.
Since 0.5
val sized : 'a sized -> 'a t
Create a generator from a size-bounded generator by first
generating a size using
QCheck.Gen.nat and passing the result to the size-bounded generator
val sized_size : int t -> 'a sized -> 'a t
Create 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
Since 0.5
val fix : ('a sized -> 'a sized) -> 'a sized
Fixpoint combinator for generating recursive, size-bounded data types.
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 ->
frequency
[1, map leaf nat;
2, map2 node (self (n/2)) (self (n/2))]
))
val generate : ?rand:Random.State.t -> n:int -> 'a t -> 'a list
generate ~n g generates n instances of g
val generate1 : ?rand:Random.State.t -> 'a t -> 'a
generate1 g generates one instance of g