Up  Next

Module QCheck.Gen

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
map2 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
map3 f g1 g2 g3 transforms three 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_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.
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
An infix synonym for QCheck.Gen.map.
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
Shuffles 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
Synonym to QCheck.Gen.nat.
Since 0.5.1
val small_int : int t
Deprecated.use QCheck.Gen.small_nat.
Small UNSIGNED integers, for retrocompatibility.
val small_signed_int : int t
Small SIGNED integers.
Since 0.5.2
val int_bound : int -> int t
Uniform integer generator producing integers within 0... bound.
Raises Invalid_argument if the argument is negative.
val int_range : int -> int -> int t
Uniform integer generator producing integers within low,high.
Raises Invalid_argument if low > high or if the range is larger than max_int.
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.
Since 0.6
val int_pos_corners : int list
Non-negative corner cases for int.
Since 0.6
val int_corners : int list
All corner cases for int.
Since 0.6
val (--) : int -> int -> int t
Synonym to QCheck.Gen.int_range.
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
Builds a string generator. String size is generated by QCheck.Gen.nat. Accepts an optional character generator (the default is QCheck.Gen.char).
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 small_list : 'a t -> 'a list t
Generates lists of small size (range 0 -- 10).
Since 0.5.3
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
Creates 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
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.
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.