clojure.test.check.generators — org.clojure/test.check 0.9.0

any clj/s

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

any-printable clj/s

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

bind clj/s

(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 clj/s

Generates one of true or false. Shrinks to false.

byte clj

Generates java.lang.Bytes, using the full byte-range.

bytes clj

Generates byte-arrays.

char clj/s

Generates character from 0-255.

char-alpha clj/s

Generate alpha characters.

char-alpha-numeric clj/s deprecated

Deprecated - use char-alphanumeric instead.

Generate alphanumeric characters.

char-alphanumeric clj/s

Generate alphanumeric characters.

char-ascii clj/s

Generate only ascii character.

choose clj/s≠

(choose lower upper)

clj

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

cljs

Create a generator that returns numbers in the range lower to upper, inclusive.

container-type clj/s

(container-type inner-type)

double clj/s

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

double* clj/s

(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 clj/s

(elements coll)

Create a generator that randomly chooses an element from coll.

Examples:

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

fmap clj/s

(fmap f gen)

frequency clj/s

(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 clj/s

(generate generator)

(generate generator size)

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

Generator cljs

generator? clj/s

(generator? x)

Test if x is a generator. Generators should be treated as opaque values.

hash-map clj/s

(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 clj/s

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

keyword clj/s

Generate keywords without namespaces.

keyword-ns clj/s

Generate keywords with optional namespaces.

large-integer clj/s

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* clj/s

(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 clj/s

(lazy-random-states rr)

Given a random number generator, returns an infinite lazy sequence of random number generators.

let clj/s≠ macro

clj

(let bindings & body)

cljs

(let &form &env 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 clj/s

(list generator)

Like vector, but generates lists.

list-distinct clj/s

(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 clj/s

(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 clj/s

(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)

nat clj/s

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

neg-int clj/s

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

no-shrink clj/s

(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 clj/s

(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 clj/s

(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 clj/s

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

ratio clj/s

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 clj/s

(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 clj/s

(resize n generator)

Create a new generator with size always bound to n.

return clj/s

(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 clj/s

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

s-pos-int clj/s

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

sample clj/s

(sample generator)

(sample generator num-samples)

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

sample-seq clj/s

(sample-seq generator)

(sample-seq generator max-size)

Return a sequence of realized values from generator.

scale clj/s

(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 clj/s

(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 clj/s

(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 clj/s

(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 clj/s

simple-type-printable clj/s

sized clj/s

(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 clj/s

(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 clj/s

Generate strings. May generate unprintable characters.

string-alpha-numeric clj/s deprecated

Deprecated - use string-alphanumeric instead.

Generate alphanumeric strings.

string-alphanumeric clj/s

Generate alphanumeric strings.

string-ascii clj/s

Generate ascii strings.

such-that clj/s

(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 clj/s

Generate symbols without namespaces.

symbol-ns clj/s

Generate symbols with optional namespaces.

tuple clj/s

(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 clj/s

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

vector clj/s

(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 clj/s

(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 clj/s

(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)