clojure.test.check.generators

->Generator

(->Generator gen)
Positional factory function for class clojure.test.check.generators.Generator.

any

A recursive generator that will generate many different, often nested, values

any-printable

Like any, but avoids characters that the shell will interpret as actions,
like 7 and 14 (bell and alternate character set command)

bind

(bind generator k)
Create a new generator that passes the result of `gen` into function
`k`. `k` should return a new generator. This allows you to create new
generators that depend on the value of other generators. For example,
to create a generator which first generates a vector of integers, and
then chooses a random element from that vector:

    (gen/bind (gen/such-that not-empty (gen/vector gen/int))
              ;; this function takes a realized vector,
              ;; and then returns a new generator which
              ;; chooses a random element from it
              gen/elements)

boolean

Generates one of `true` or `false`. Shrinks to `false`.

byte

Generates `java.lang.Byte`s, using the full byte-range.

bytes

Generates byte-arrays.

char

Generates character from 0-255.

char-alpha

Generate alpha characters.

char-alpha-numeric

deprecated in 0.6.0

Deprecated - use char-alphanumeric instead.

Generate alphanumeric characters.

char-alphanumeric

Generate alphanumeric characters.

char-ascii

Generate only ascii character.

choose

(choose lower upper)
Create a generator that returns long integers in the range `lower` to `upper`, inclusive.

container-type

(container-type inner-type)

double

Generates 64-bit floating point numbers from the entire range,
including +/- infinity and NaN. Use double* for more control.

double*

(double* {:keys [infinite? NaN? min max], :or {infinite? true, NaN? true}})
Generates a 64-bit floating point number. Options:

  :infinite? - whether +/- infinity can be generated (default true)
  :NaN?      - whether NaN can be generated (default true)
  :min       - minimum value (inclusive, default none)
  :max       - maximum value (inclusive, default none)

Note that the min/max options must be finite numbers. Supplying a
min precludes -Infinity, and supplying a max precludes +Infinity.

elements

(elements coll)
Create a generator that randomly chooses an element from `coll`.

Examples:

    (gen/elements [:foo :bar :baz])

fmap

(fmap f gen)

frequency

(frequency pairs)
Create a generator that chooses a generator from `pairs` based on the
provided likelihoods. The likelihood of a given generator being chosen is
its likelihood divided by the sum of all likelihoods

Examples:

    (gen/frequency [[5 gen/int] [3 (gen/vector gen/int)] [2 gen/boolean]])

generate

(generate generator)(generate generator size)
Returns a single sample value from the generator, using a default
size of 30.

generator?

(generator? x)
Test if `x` is a generator. Generators should be treated as opaque values.

hash-map

(hash-map & kvs)
Like clojure.core/hash-map, except the values are generators.
 Returns a generator that makes maps with the supplied keys and
 values generated using the supplied generators.

Examples:

  (gen/hash-map :a gen/boolean :b gen/nat)

int

Generates a positive or negative integer bounded by the generator's
`size` parameter.
(Really returns a long)

keyword

Generate keywords without namespaces.

keyword-ns

added in 0.5.9

Generate keywords with optional namespaces.

large-integer

Generates a platform-native integer from the full available range
(in clj, 64-bit Longs, and in cljs, numbers between -(2^53 - 1) and
(2^53 - 1)).

Use large-integer* for more control.

large-integer*

(large-integer* {:keys [min max]})
Like large-integer, but accepts options:

  :min  the minimum integer (inclusive)
  :max  the maximum integer (inclusive)

Both :min and :max are optional.

lazy-random-states

(lazy-random-states rr)
Given a random number generator, returns an infinite lazy sequence
of random number generators.

let

macro

(let bindings & body)
Macro for building generators using values from other generators.
Uses a binding vector with the same syntax as clojure.core/let,
where the right-hand side of the binding pairs are generators, and
the left-hand side are names (or destructuring forms) for generated
values.

Subsequent generator expressions can refer to the previously bound
values, in the same way as clojure.core/let.

The body of the let can be either a value or a generator, and does
the expected thing in either case. In this way let provides the
functionality of both `bind` and `fmap`.

Examples:

  (gen/let [strs (gen/not-empty (gen/list gen/string))
            s (gen/elements strs)]
    {:some-strings strs
     :one-of-those-strings s})

  ;; generates collections of "users" that have integer IDs
  ;; from 0...N-1, but are in a random order
  (gen/let [users (gen/list (gen/hash-map :name gen/string-ascii
                                          :age gen/nat))]
    (->> users
         (map #(assoc %2 :id %1) (range))
         (gen/shuffle)))

list

(list generator)
Like `vector`, but generates lists.

list-distinct

(list-distinct gen)(list-distinct gen opts)
Generates a list of elements from the given generator, with the
guarantee that the elements will be distinct.

If the generator cannot or is unlikely to produce enough distinct
elements, this generator will fail in the same way as such-that.

Available options:

  :num-elements  the fixed size of generated vectors
  :min-elements  the min size of generated vectors
  :max-elements  the max size of generated vectors
  :max-tries     the number of times the generator will be tried before
                 failing when it does not produce distinct elements
                 (default 10)

list-distinct-by

(list-distinct-by key-fn gen)(list-distinct-by key-fn gen opts)
Generates a list of elements from the given generator, with the
guarantee that (map key-fn the-list) will be distinct.

If the generator cannot or is unlikely to produce enough distinct
elements, this generator will fail in the same way as such-that.

Available options:

  :num-elements  the fixed size of generated vectors
  :min-elements  the min size of generated vectors
  :max-elements  the max size of generated vectors
  :max-tries     the number of times the generator will be tried before
                 failing when it does not produce distinct elements
                 (default 10)

map

(map key-gen val-gen)(map key-gen val-gen opts)
Create a generator that generates maps, with keys chosen from
`key-gen` and values chosen from `val-gen`.

If the key generator cannot or is unlikely to produce enough distinct
elements, this generator will fail in the same way as such-that.

Available options:

  :num-elements  the fixed size of generated vectors
  :min-elements  the min size of generated vectors
  :max-elements  the max size of generated vectors
  :max-tries     the number of times the generator will be tried before
                 failing when it does not produce distinct elements
                 (default 10)

map->Generator

(map->Generator m__6289__auto__)
Factory function for class clojure.test.check.generators.Generator, taking a map of keywords to field values.

nat

Generates natural numbers, starting at zero. Shrinks to zero.

neg-int

Generate negative integers bounded by the generator's `size` parameter.

no-shrink

(no-shrink gen)
Create a new generator that is just like `gen`, except does not shrink
at all. This can be useful when shrinking is taking a long time or is not
applicable to the domain.

not-empty

(not-empty gen)
Modifies a generator so that it doesn't generate empty collections.

Examples:

    ;; generate a vector of booleans, but never the empty vector
    (gen/not-empty (gen/vector gen/boolean))

one-of

(one-of generators)
Create a generator that randomly chooses a value from the list of
provided generators. Shrinks toward choosing an earlier generator,
as well as shrinking the value generated by the chosen generator.

Examples:

    (one-of [gen/int gen/boolean (gen/vector gen/int)])

pos-int

Generate positive integers bounded by the generator's `size` parameter.

ratio

Generates a `clojure.lang.Ratio`. Shrinks toward 0. Not all values generated
will be ratios, as many values returned by `/` are not ratios.

recursive-gen

added in 0.5.9

(recursive-gen container-gen-fn scalar-gen)
This is a helper for writing recursive (tree-shaped) generators. The first
argument should be a function that takes a generator as an argument, and
produces another generator that 'contains' that generator. The vector function
in this namespace is a simple example. The second argument is a scalar
generator, like boolean. For example, to produce a tree of booleans:

  (gen/recursive-gen gen/vector gen/boolean)

Vectors or maps either recurring or containing booleans or integers:

  (gen/recursive-gen (fn [inner] (gen/one-of [(gen/vector inner)
                                              (gen/map inner inner)]))
                     (gen/one-of [gen/boolean gen/int]))

resize

(resize n generator)
Create a new generator with `size` always bound to `n`.

return

(return value)
Create a generator that always returns `value`,
and never shrinks. You can think of this as
the `constantly` of generators.

s-neg-int

Generate strictly negative integers bounded by the generator's `size`
parameter.

s-pos-int

Generate strictly positive integers bounded by the generator's `size`
parameter.

sample

(sample generator)(sample generator num-samples)
Return a sequence of `num-samples` (default 10)
realized values from `generator`.

sample-seq

(sample-seq generator)(sample-seq generator max-size)
Return a sequence of realized values from `generator`.

scale

(scale f generator)
Create a new generator that modifies the size parameter by the given function. Intended to
support generators with sizes that need to grow at different rates compared to the normal
linear scaling.

set

(set gen)(set gen opts)
Generates a set of elements from the given generator.

If the generator cannot or is unlikely to produce enough distinct
elements, this generator will fail in the same way as such-that.

Available options:

  :num-elements  the fixed size of generated vectors
  :min-elements  the min size of generated vectors
  :max-elements  the max size of generated vectors
  :max-tries     the number of times the generator will be tried before
                 failing when it does not produce distinct elements
                 (default 10)

shrink-2

(shrink-2 gen)
Create a new generator like `gen`, but will consider nodes for shrinking
even if their parent passes the test (up to one additional level).

shuffle

added in 0.6.0

(shuffle coll)
Create a generator that generates random permutations of `coll`. Shrinks
toward the original collection: `coll`. `coll` will be turned into a vector,
if it's not already.

simple-type

simple-type-printable

sized

(sized sized-gen)
Create a generator that depends on the size parameter.
`sized-gen` is a function that takes an integer and returns
a generator.

sorted-set

(sorted-set gen)(sorted-set gen opts)
Generates a sorted set of elements from the given generator.

If the generator cannot or is unlikely to produce enough distinct
elements, this generator will fail in the same way as such-that.

Available options:

  :num-elements  the fixed size of generated vectors
  :min-elements  the min size of generated vectors
  :max-elements  the max size of generated vectors
  :max-tries     the number of times the generator will be tried before
                 failing when it does not produce distinct elements
                 (default 10)

string

Generate strings. May generate unprintable characters.

string-alpha-numeric

deprecated in 0.6.0

Deprecated - use string-alphanumeric instead.

Generate alphanumeric strings.

string-alphanumeric

Generate alphanumeric strings.

string-ascii

Generate ascii strings.

such-that

(such-that pred gen)(such-that pred gen max-tries)
Create a generator that generates values from `gen` that satisfy predicate
`pred`. Care is needed to ensure there is a high chance `gen` will satisfy
`pred`. By default, `such-that` will try 10 times to generate a value that
satisfies the predicate. If no value passes this predicate after this number
of iterations, a runtime exception will be throw. You can pass an optional
third argument to change the number of times tried. Note also that each
time such-that retries, it will increase the size parameter.

Examples:

    ;; generate non-empty vectors of integers
    ;; (note, gen/not-empty does exactly this)
    (gen/such-that not-empty (gen/vector gen/int))

symbol

Generate symbols without namespaces.

symbol-ns

added in 0.5.9

Generate symbols with optional namespaces.

tuple

(tuple & generators)
Create a generator that returns a vector, whose elements are chosen
from the generators in the same position. The individual elements shrink
according to their generator, but the value will never shrink in count.

Examples:

    (def t (tuple gen/int gen/boolean))
    (sample t)
    ;; => ([1 true] [2 true] [2 false] [1 false] [0 true] [-2 false] [-6 false]
    ;; =>  [3 true] [-4 false] [9 true]))

uuid

Generates a random type-4 UUID. Does not shrink.

vector

(vector generator)(vector generator num-elements)(vector generator min-elements max-elements)
Create a generator whose elements are chosen from `gen`. The count of the
vector will be bounded by the `size` generator parameter.

vector-distinct

(vector-distinct gen)(vector-distinct gen opts)
Generates a vector of elements from the given generator, with the
guarantee that the elements will be distinct.

If the generator cannot or is unlikely to produce enough distinct
elements, this generator will fail in the same way as such-that.

Available options:

  :num-elements  the fixed size of generated vectors
  :min-elements  the min size of generated vectors
  :max-elements  the max size of generated vectors
  :max-tries     the number of times the generator will be tried before
                 failing when it does not produce distinct elements
                 (default 10)

vector-distinct-by

(vector-distinct-by key-fn gen)(vector-distinct-by key-fn gen opts)
Generates a vector of elements from the given generator, with the
guarantee that (map key-fn the-vector) will be distinct.

If the generator cannot or is unlikely to produce enough distinct
elements, this generator will fail in the same way as such-that.

Available options:

  :num-elements  the fixed size of generated vectors
  :min-elements  the min size of generated vectors
  :max-elements  the max size of generated vectors
  :max-tries     the number of times the generator will be tried before
                 failing when it does not produce distinct elements
                 (default 10)