Simple-check 0.5.6 API documentation

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

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

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)

Generates one of true or false. Shrinks to false.

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

Generates byte-arrays.

Generates character from 0-255.

Generate alpha-numeric characters.

Generate only ascii character.

Create a generator that returns numbers in the range min-range to max-range, inclusive.

Create a generator that randomly chooses an element from coll.

Examples:

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

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

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)

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

Generate keywords.

Like vector, but generators lists.

Create a generator that generates maps, with keys chosen from key-gen and values chosen from val-gen.

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

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

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.

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

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

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

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

Create a new generator with size always bound to n.

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

Create a lazy-seq of all of the (unique) nodes in a shrink-tree. This assumes that two nodes with the same value have the same children. While it's not common, it's possible to create trees that don't fit that description. This function is significantly faster than brute-force enumerating all of the nodes in a tree, as there will be many duplicates.

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

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

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

Return a sequence of realized values from generator.

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

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

Generate strings. May generate unprintable characters.

Generate alpha-numeric strings.

Generate ascii strings.

Create a generator that generates values from gen that satisfy predicate f. Care is needed to ensure there is a high chance gen will satisfy f, otherwise it will keep trying forever. Eventually we will add another generator combinator that only tries N times before giving up. In the Haskell version this is called suchThatMaybe.

Examples:

;; generate non-empty vectors of integers
(such-that not-empty (gen/vector gen/int))

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

Create a generator whose elements are chosen from gen. The count of the vector will be bounded by the size generator parameter.