The check-it Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The check-it Reference Manual

This is the check-it Reference Manual, version 0.1.0, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 03:05:17 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

check-it

Build Status

This is a randomized property-based testing library for Common Lisp. Rather than being a full-fledged general test framework in its own right, it's designed to embed randomized tests in whatever framework you like.

The basic idea behind QuickCheck-style tools is simple, but they become complicated as different features interact, so some behaviors and API details may not be stable. I recommend that you configure your projects' test systems to optionally exclude check-it tests (e.g. by keeping them all in a separate package from your other tests) so that a breaking change won't impede your development workflow too much.

Table of Contents

Generating

The heart of check-it is the generator DSL. Generator objects are constructed using the macro generator, which takes a single argument: a form denoting a type spec. Generator type specs are not exactly the same as Common Lisp type specs, but they're designed to look syntactically similar.

Values are generated by calling the function generate on generator objects. This function is normally called behind the scenes during a test run, but it can also be used à la carte to generate interesting data for other purposes.

The different varieties of generators are:

Number Generators

The integer generator accepts the same syntax as the standard compound type specifier syntax for integers:

;; generates any integer
(integer)

;; also generates any integer
(integer * *)

;; generates integers greater than or equal to 5
(integer 5)

;; generates integers less than or equal to 10
(integer * 10)

;; generates integers between -3 and 4
(integer -3 4)

The real generator works similarly.

A number generator's bounds can also be expressions: (real 0 (* 2 pi))

You could even do things like this if you wanted:

(let ((x (something)))
  (generator (real 0 x)))

But you should probably define a custom generator type or use a combinator like map or chain instead.

In addition to the constraints you choose in the type specifier, the absolute values of generated numbers are also bounded by the parameter *size*.

Character Generators

The character generator accepts a syntax much like the number generators. It accepts either characters or character codes as bounding values:

;; any character
(character)

;; any character, again
(character * *)

(character #\a #\f)

;; same as previous
(character 97 102)

Two additional character generators are predefined for common cases: alpha for #\a-#\z and #\A-#\Z, and alphanumeric for #\a-#\z, #\A-#\Z, and #\0-#\9.

List and Tuple Generators

The list generator generates a list of values each generated by its subgenerator. The generated list has a random length bounded by the parameter *list-size*.

(let ((a-generator
       (generator (list (integer)))))
  (generate a-generator))
;; sample result: (9 -3 3 -2 3 10 6 -8 9 10)

You can also specify length bounds with :min-length and :max-length:

(generator (list (integer) :min-length 5 :max-length 10))

:max-length provides a permanent bound, but *list-size* can change in certain situations described further down in this document. For convenience, you can specify lists of fixed length with a single keyword argument:

(generator (list (integer) :length 5))

The tuple generator generates a list containing one result from each of its subgenerators in order, so unlike the list generator, its length is fixed:

(let ((another-generator
       (generator (tuple (integer) (real)))))
  (generate another-generator))
;; sample result: (-6 -4.168296)

String Generator

A special form of the list generator (equally length bounded by *list-size*) is the string generator to generate strings consisting of randomly chosen alphanumeric characters.

(generate (generator (string :min-length 10 :max-length 20)))
;; sample output: "2k464h72CZ4TE1KQ"

Or Generator

The or generator randomly chooses one of its subgenerators and returns its result. It biases its choice in certain situations, to be described later.

(generate (generator (or (integer) (real))))
;; sample result: -1.0087109

Guard Generator

The guard generator generates a result from its subgenerator and checks whether the result passes the guard predicate. If not, it keeps generating new results until it finds a value that does.

;; same range of values as (integer 5)
(guard (lambda (x) (>= x 5)) (integer))

Struct Generator

The struct generator generates a struct of a given struct type with slots generated by the corresponding slot generators. So if you have a struct definition that looks like:

(defstruct a-struct
  a-slot
  another-slot)

You can create a generator type spec that looks like:

(struct a-struct :a-slot (integer) :another-slot (real))

In order to use this kind of generator, the struct type must have a default constructor function. Of course, you can always use simple generators to specify all the atomic data elements you need and manually assemble them into more complex data structures at the start of your test body. However, for complex, nested generator forms, it may be difficult or impossible to unambiguously specify where to find the output of some deep sub-sub-generator that you wish to transform. For those situations, you need...

Mapped Generators

A mapped generator applies a transformation function to the outputs of its subgenerators. This is a mapping in the mathematical sense, not the Lispy one; it does not map the function repeatedly to each element of a list. The transformation function should not mutate its arguments.

(let ((*size* 100)
      (g (generator (tuple (map (lambda (x y) (list x y))
                                (integer 1 10)
                                (integer 20 30))
                           (map (lambda (x y) (list x (+ x y)))
                                (integer 1 9)
                                10)))))
  (generate g))
;;; sample result: ((10 28) (7 17))

Chained Generators

You can create generators whose behavior is parameterized by other generators with chain. Every time a value is created from a chained generator,

  1. Each parameterizing generator generates a new value,
  2. Those values are bound to the associated variable names in the body of the chain form,
  3. The body is evaluated to construct a new parameterized generator, and
  4. The parameterized generator generates the end value.

For example, you can generate random NxN matrices like this:

(let ((g (generator
          (chain ((n (integer 1 5)))
            (generator (list
                        (list (integer) :length n)
                        :length n))))))
  (generate g))
;; sample result: ((-2 0 -9 -6) (6 7 -3 -7) (9 -10 10 6) (-6 -10 -10 8))

The generator macro is implicitly wrapped around each parameterizer form for brevity. However, the body is regular Lisp code, so you must use generator to define your parameterized generator there.

If you provide only a name for a parameterizer instead of a list containing a name and a generator form, the name is assumed to be a variable already bound to a generator in the surrounding Lisp code:

(let ((x (generator (integer 1 3)))
      (y (generator (integer 8 10))))
  (generator (chain (x y)
               (list (integer) :min-length x :max-length y))))

User-Defined Generators

You can define your own generator types with def-generator.

User-defined generators can take a set of arguments specified by an ordinary lambda list, evaluated at the time of a generator object's construction. They can also be recursive (in which case recursive definition is evaluated anew to construct a generator, allowing child recursions be parameterized by parent recursions). Here's a useless example:

;; same range of values as (integer x)
(def-generator recursive (x) (generator (or (integer x) (recursive x))))

You can also create higher-order recursive generators. However, each subgenerator needs to be a unique object for check-it to work correctly, so you need to explicitly create them like this:

(def-generator higher-order (generator-maker)
  (generator (or (funcall generator-maker)
                 (higher-order generator-maker))))

(generate (generator (higher-order (lambda () (generator (integer))))))

With naive generation strategies, recursive generators can easily generate values of unbounded size. There are currently two ways to dampen the feedback explosion of recursively-generated data structures.

When a user-defined generator appears as an alternative in an or generator, its relative probability of being chosen decreases with each recursive descent.

;; normally there would be an 87.5% chance of recursing on each generation
;; essentially guaranteeing unbounded growth
(def-generator tuple-explode (x)
  (generator (tuple (or x (tuple-explode (+ 1 x)))
                    (or x (tuple-explode (+ 1 x)))
                    (or x (tuple-explode (+ 1 x))))))

(let ((*recursive-bias-decay* 1.2)
      (*bias-sensitivity* 1.5))
  (generate (generator (tuple-explode 0))))
;; sample result: (0 0 (1 1 ((3 (4 4 (5 5 5)) (4 4 (5 5 5))) (3 3 3) 2)))

The change in bias at each recursive step is controlled by the parameter *recursive-bias-decay*, and the way biases of different alternatives interact to produce the actual relative probabilities is controlled by *bias-sensitivity*. The whole apparatus is set up in such a way that these parameters can be tuned without causing one alternative's probability to sharply shoot off toward zero or one, so you can play around with them and discover values that produce a reasonable distribution for your needs.

Additionally, the maximum possible list length is reduced with every list generation that occurs within the dynamic scope of another list generation.

(def-generator list-explode ()
  (generator (or (integer) (list (list-explode)))))

(let ((*list-size* 10))
  (generate (generator (list-explode))))
;; sample result:
;; ((((-5 -9 (-7 -4)) NIL NIL (6) NIL) (-7 (3 (-4 (NIL)))) (5 -3) 3
;;   ((1 (4) 5) NIL ((NIL) -10)) -5 9)
;;  ((((-3) -6) NIL -4 (-5) -4)) ((-9) 0 1 0 3) -3 NIL)

But it's your responsibility not to write type specs that can't possibly generate anything other than unbounded values.

(def-generator inherently-unbounded ()
  (generator (tuple (integer) (inherently-unbounded))))

Generator Macros

You can define transformations using destructuring lambda lists that work just like macros within the generator DSL. These will be expanded in any place where a generator expression would be expected.

(def-genex-macro maybe (form)
  `(or nil ,form))

(generate (generator (list (maybe (integer)))))
;; sample result: (NIL NIL NIL NIL 7 -4 2 NIL NIL 3 7 -8 NIL 7)

Checking

Use the check-it macro to perform a test run. Here's another useless example:

(let ((*num-trials* 100))
  (check-it (generator (integer))
            (lambda (x) (integerp x))))

This will generate *num-trials* random values and test them against the test predicate. If a random value fails, check-it will search for values of smaller complexity until it finds the least complex value it can that fails the test while respecting the generator's composite type spec, and print a failure description to *check-it-output*.

If the test predicate signals an uncaught error, check-it will catch it and treat it as a test failure, both for the initial test and the search for smaller failing values. If you want to test for an expected error, you should explicitly handle it within the test predicate and return a non-nil value.

check-it itself returns t if every trial passed and nil if one failed, so you can embed check-it forms within whatever test framework you're already using. Here's what a check-it test might look like using Stefil:

(deftest useless-test ()
  (let ((*num-trials* 100))
    (is (check-it (generator (integer))
                  (lambda (x) (integerp x))))))

Regression Cases

You can configure the check-it macro to automatically add new deterministic regression tests to your project when a randomized test fails. Here's the worst example yet:

(deftest some-test-with-regression-cases ()
  (is
   (check-it (generator (struct a-struct
                                :a-slot (integer)
                                :another-slot (integer)))
             (lambda (x) (= (slot-value x 'a-slot) 0))
             :regression-id some-test-with-regression-cases
             :regression-file my-regression-test-file)))

This will (most likely) discover a failing case, shrink it, and append the following code to my-regression-test-file:

(REGRESSION-CASE SOME-TEST-WITH-REGRESSION-CASES "#S(A-STRUCT :A-SLOT 1 :ANOTHER-SLOT 0)")

Regression cases must be given a regression-id to know which check-it form they apply to. It's probably simplest just to tag them with the same symbol you used to name the test. (This makes your test code a little more redundant, but it keeps check-it simple and framework-agnostic.) Although generators are meant to generate data with readable print representations, some objects (like structs) cannot be dumped into FASL files, so regression cases are encoded as strings which are read after the file is loaded in order to delay their construction.

It is recommended that you output your regression cases to a special file that initially contains only the line (in-package :same-package-as-test-package) and is loaded as part of the same system as your tests. Then the next time you run a check-it test, all the regression cases will be checked before any random cases are generated, which should hopefully light a fire under your ass to fix bugs you've already discovered before you hunt for new ones.

You can also provide a list of explicit inline examples that will also be checked before any random cases are generated using the :examples keyword argument to check-it.

Eventually, check-it will be integrated more elegantly with individual test frameworks by extending their APIs. For now, you can reduce code repetition by declaring a file to output regression cases for all regression-ids in a given package with (register-package-regression-file :package file), so you don't have to mention the file in each test.

Note on Mapped Generators

All data types constructed with check-it's essential generators can be successfully converted to readable print representations, but it's possible that something you create with a mapped generator will produce a data type that can't. If you want to enable regression cases for tests involving unexternalizable data types, try to find a way to construct those data types within the test body if possible. Eventually, check-it may use a more robust solution for externalization, but this simple method can get you surprisingly far.

Shrinking

When a generated value fails a test, check-it searches for a simpler value as follows:

An integer generator shrinks toward zero, or if zero is not included in its range, toward the bound in its type spec that has the smaller absolute value.

A real generator doesn't shrink, because the shrinkage procedure only really makes sense over discrete search spaces.

A list generator shrinks by repeatedly removing elements from the list and/or shrinking individual elements while respecting the type spec of the subgenerator.

An or generator shrinks by shrinking the one generator among its alternatives that was involved in generating the failed value. However, if this generator's value cannot be shrunk further, and other alternatives available to the or generator specify constant values, then one of those constant values may be substituted instead. So if the generator (or (integer 5) :a-keyword) failed after generating 5 from the integer subgenerator, check-it will attempt to use :a-keyword. This opens up more possible shrinkage paths in the overall space defined by the or generator's parent generators.

Other generators shrink by recursively shrinking their subgenerators while still respecting the overall type spec.

For mapped generators, the subgenerators shrink according to their own internal degrees of freedom, but the mapping is applied to the candidate replacement values from the subgenerators to determine whether resulting composite data structure still fails the test. There's a bit of a thorny issue here in that check-it doesn't know for sure whether a simpler value in a subgenerator will really correspond to a simpler value after the mapping is applied. For this reason, good mapping functions should typically specify one-to-one mappings that simply assemble new data structures, and more complicated logic should go in the test body.

For chained generators, the parameterizers are not involved in the shrinking process; the parameterized generator is shrunk according to the parameters it had when it failed the test.

Note on Destructive Operations

Currently, generators cache their generated values and often make use of them during the shrinking process. If you perform destructive operations on the input to a test function, shrinking may not work correctly. This will be fixed eventually. In the meantime, you can turn off shrinking by giving check-it the keyword argument :shrink-failures nil.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 check-it

Author

Kyle Littler

Home Page

https://github.com/DalekBaldwin/check-it

License

LLGPL

Description

A randomized property-based testing tool for Common Lisp.

Long Description

# check-it

[![Build Status](https://travis-ci.org/DalekBaldwin/check-it.svg?branch=master)](https://travis-ci.org/DalekBaldwin/check-it)

This is a randomized property-based testing library for Common Lisp. Rather than being a full-fledged general test framework in its own right, it’s designed to embed randomized tests in whatever framework you like.

The basic idea behind QuickCheck-style tools is simple, but they become complicated as different features interact, so some behaviors and API details may not be stable. I recommend that you configure your projects’ test systems to optionally exclude check-it tests (e.g. by keeping them all in a separate package from your other tests) so that a breaking change won’t impede your development workflow too much.

## Table of Contents
* [Generating](#generating)
* [Number Generators](#number-generators)
* [Character Generators](#character-generators)
* [List and Tuple Generators](#list-and-tuple-generators)
* [String Generator](#string-generator)
* [Or Generator](#or-generator)
* [Guard Generator](#guard-generator)
* [Struct Generator](#struct-generator)
* [Mapped Generators](#mapped-generators)
* [Chained Generators](#chained-generators)
* [User-Defined Generators](#user-defined-generators)
* [Generator Macros](#generator-macros)
* [Checking](#checking)
* [Regression Cases](#regression-cases)
* [Note on Mapped Generators](#note-on-mapped-generators)
* [Shrinking](#shrinking)
* [Note on Destructive Operations](#note-on-destructive-operations)

## Generating

The heart of check-it is the generator DSL. Generator objects are constructed using the macro ‘generator‘, which takes a single argument: a form denoting a type spec. Generator type specs are not exactly the same as Common Lisp type specs, but they’re designed to look syntactically similar.

Values are generated by calling the function ‘generate‘ on generator objects. This function is normally called behind the scenes during a test run, but it can also be used à la carte to generate interesting data for other purposes.

The different varieties of generators are:

### Number Generators

The ‘integer‘ generator accepts the same syntax as the standard compound type specifier syntax for integers:

“‘lisp
;; generates any integer
(integer)

;; also generates any integer
(integer * *)

;; generates integers greater than or equal to 5
(integer 5)

;; generates integers less than or equal to 10
(integer * 10)

;; generates integers between -3 and 4
(integer -3 4)
“‘

The ‘real‘ generator works similarly.

A number generator’s bounds can also be expressions: ‘(real 0 (* 2 pi))‘

You could even do things like this if you wanted:

“‘lisp
(let ((x (something)))
(generator (real 0 x)))
“‘

But you should probably define a custom generator type or use a combinator like ‘map‘ or ‘chain‘ instead.

In addition to the constraints you choose in the type specifier, the absolute values of generated numbers are also bounded by the parameter ‘*size*‘.

### Character Generators

The ‘character‘ generator accepts a syntax much like the number generators. It accepts either characters or character codes as bounding values:

“‘lisp
;; any character
(character)

;; any character, again
(character * *)

(character #\a #\f)

;; same as previous
(character 97 102)
“‘

Two additional character generators are predefined for common cases: ‘alpha‘ for ‘#\a‘-‘#\z‘ and ‘#\A‘-‘#\Z‘, and ‘alphanumeric‘ for ‘#\a‘-‘#\z‘, ‘#\A‘-‘#\Z‘, and ‘#\0‘-‘#\9‘.

### List and Tuple Generators

The ‘list‘ generator generates a list of values each generated by its subgenerator. The generated list has a random length bounded by the parameter ‘*list-size*‘.

“‘lisp
(let ((a-generator
(generator (list (integer)))))
(generate a-generator))
;; sample result: (9 -3 3 -2 3 10 6 -8 9 10)
“‘

You can also specify length bounds with ‘:min-length‘ and ‘:max-length‘:

“‘lisp
(generator (list (integer) :min-length 5 :max-length 10))
“‘

‘:max-length‘ provides a permanent bound, but ‘*list-size*‘ can change in certain situations described further down in this document. For convenience, you can specify lists of fixed length with a single keyword argument:

“‘lisp
(generator (list (integer) :length 5))
“‘

The ‘tuple‘ generator generates a list containing one result from each of its subgenerators in order, so unlike the ‘list‘ generator, its length is fixed:

“‘lisp
(let ((another-generator
(generator (tuple (integer) (real)))))
(generate another-generator))
;; sample result: (-6 -4.168296)
“‘

### String Generator

A special form of the ‘list‘ generator (equally length bounded by ‘*list-size*‘) is the ‘string‘ generator to generate strings consisting of randomly chosen alphanumeric characters.

“‘lisp
(generate (generator (string :min-length 10 :max-length 20)))
;; sample output: "2k464h72CZ4TE1KQ"
“‘

### Or Generator

The ‘or‘ generator randomly chooses one of its subgenerators and returns its result. It biases its choice in certain situations, to be described later.

“‘lisp
(generate (generator (or (integer) (real))))
;; sample result: -1.0087109
“‘

### Guard Generator

The ‘guard‘ generator generates a result from its subgenerator and checks whether the result passes the guard predicate. If not, it keeps generating new results until it finds a value that does.

“‘lisp
;; same range of values as (integer 5)
(guard (lambda (x) (>= x 5)) (integer))
“‘

### Struct Generator

The ‘struct‘ generator generates a struct of a given struct type with slots generated by the corresponding slot generators. So if you have a struct definition that looks like:

“‘lisp
(defstruct a-struct
a-slot
another-slot)
“‘

You can create a generator type spec that looks like:

“‘lisp
(struct a-struct :a-slot (integer) :another-slot (real))
“‘

In order to use this kind of generator, the struct type must have a default constructor function. Of course, you can always use simple generators to specify all the atomic data elements you need and manually assemble them into more complex data structures at the start of your test body. However, for complex, nested generator forms, it may be difficult or impossible to unambiguously specify where to find the output of some deep sub-sub-generator that you wish to transform. For those situations, you need...

### Mapped Generators

A mapped generator applies a transformation function to the outputs of its subgenerators. This is a mapping in the mathematical sense, not the Lispy one; it does not map the function repeatedly to each element of a list. The transformation function should not mutate its arguments.

“‘lisp
(let ((*size* 100)
(g (generator (tuple (map (lambda (x y) (list x y))
(integer 1 10)
(integer 20 30))
(map (lambda (x y) (list x (+ x y)))
(integer 1 9)
10)))))
(generate g))
;;; sample result: ((10 28) (7 17))
“‘

### Chained Generators

You can create generators whose behavior is parameterized by other generators with ‘chain‘. Every time a value is created from a chained generator,

1. Each parameterizing generator generates a new value,
2. Those values are bound to the associated variable names in the body of the ‘chain‘ form,
3. The body is evaluated to construct a new parameterized generator, and
4. The parameterized generator generates the end value.

For example, you can generate random NxN matrices like this:

“‘lisp
(let ((g (generator
(chain ((n (integer 1 5)))
(generator (list
(list (integer) :length n)
:length n))))))
(generate g))
;; sample result: ((-2 0 -9 -6) (6 7 -3 -7) (9 -10 10 6) (-6 -10 -10 8))
“‘

The ‘generator‘ macro is implicitly wrapped around each parameterizer form for brevity. However, the body is regular Lisp code, so you must use ‘generator‘ to define your parameterized generator there.

If you provide only a name for a parameterizer instead of a list containing a name and a generator form, the name is assumed to be a variable already bound to a generator in the surrounding Lisp code:

“‘lisp
(let ((x (generator (integer 1 3)))
(y (generator (integer 8 10))))
(generator (chain (x y)
(list (integer) :min-length x :max-length y))))
“‘

### User-Defined Generators

You can define your own generator types with ‘def-generator‘.

User-defined generators can take a set of arguments specified by an ordinary lambda list, evaluated at the time of a generator object’s construction. They can also be recursive (in which case recursive definition is evaluated anew to construct a generator, allowing child recursions be parameterized by parent recursions). Here’s a useless example:

“‘lisp
;; same range of values as (integer x)
(def-generator recursive (x) (generator (or (integer x) (recursive x))))
“‘

You can also create higher-order recursive generators. However, each subgenerator needs to be a unique object for check-it to work correctly, so you need to explicitly create them like this:

“‘lisp
(def-generator higher-order (generator-maker)
(generator (or (funcall generator-maker)
(higher-order generator-maker))))

(generate (generator (higher-order (lambda () (generator (integer))))))
“‘

With naive generation strategies, recursive generators can easily generate values of unbounded size. There are currently two ways to dampen the feedback explosion of recursively-generated data structures.

When a user-defined generator appears as an alternative in an ‘or‘ generator, its relative probability of being chosen decreases with each recursive descent.

“‘lisp
;; normally there would be an 87.5% chance of recursing on each generation
;; essentially guaranteeing unbounded growth
(def-generator tuple-explode (x)
(generator (tuple (or x (tuple-explode (+ 1 x)))
(or x (tuple-explode (+ 1 x)))
(or x (tuple-explode (+ 1 x))))))

(let ((*recursive-bias-decay* 1.2)
(*bias-sensitivity* 1.5))
(generate (generator (tuple-explode 0))))
;; sample result: (0 0 (1 1 ((3 (4 4 (5 5 5)) (4 4 (5 5 5))) (3 3 3) 2)))
“‘

The change in bias at each recursive step is controlled by the parameter ‘*recursive-bias-decay*‘, and the way biases of different alternatives interact to produce the actual relative probabilities is controlled by ‘*bias-sensitivity*‘. The whole apparatus is set up in such a way that these parameters can be tuned without causing one alternative’s probability to sharply shoot off toward zero or one, so you can play around with them and discover values that produce a reasonable distribution for your needs.

Additionally, the maximum possible list length is reduced with every ‘list‘ generation that occurs within the dynamic scope of another ‘list‘ generation.

“‘lisp
(def-generator list-explode ()
(generator (or (integer) (list (list-explode)))))

(let ((*list-size* 10))
(generate (generator (list-explode))))
;; sample result:
;; ((((-5 -9 (-7 -4)) NIL NIL (6) NIL) (-7 (3 (-4 (NIL)))) (5 -3) 3
;; ((1 (4) 5) NIL ((NIL) -10)) -5 9)
;; ((((-3) -6) NIL -4 (-5) -4)) ((-9) 0 1 0 3) -3 NIL)
“‘

But it’s your responsibility not to write type specs that can’t possibly generate anything other than unbounded values.

“‘lisp
(def-generator inherently-unbounded ()
(generator (tuple (integer) (inherently-unbounded))))
“‘

### Generator Macros

You can define transformations using destructuring lambda lists that work just like macros within the generator DSL. These will be expanded in any place where a generator expression would be expected.

“‘lisp
(def-genex-macro maybe (form)
‘(or nil ,form))

(generate (generator (list (maybe (integer)))))
;; sample result: (NIL NIL NIL NIL 7 -4 2 NIL NIL 3 7 -8 NIL 7)
“‘

## Checking

Use the ‘check-it‘ macro to perform a test run. Here’s another useless example:

“‘lisp
(let ((*num-trials* 100))
(check-it (generator (integer))
(lambda (x) (integerp x))))
“‘

This will generate ‘*num-trials*‘ random values and test them against the test predicate. If a random value fails, check-it will search for values of smaller complexity until it finds the least complex value it can that fails the test while respecting the generator’s composite type spec, and print a failure description to ‘*check-it-output*‘.

If the test predicate signals an uncaught error, ‘check-it‘ will catch it and treat it as a test failure, both for the initial test and the search for smaller failing values. If you want to test for an expected error, you should explicitly handle it within the test predicate and return a non-‘nil‘ value.

‘check-it‘ itself returns ‘t‘ if every trial passed and ‘nil‘ if one failed, so you can embed ‘check-it‘ forms within whatever test framework you’re already using. Here’s what a check-it test might look like using Stefil:

“‘lisp
(deftest useless-test ()
(let ((*num-trials* 100))
(is (check-it (generator (integer))
(lambda (x) (integerp x))))))
“‘

### Regression Cases

You can configure the ‘check-it‘ macro to automatically add new deterministic regression tests to your project when a randomized test fails. Here’s the worst example yet:

“‘lisp
(deftest some-test-with-regression-cases ()
(is
(check-it (generator (struct a-struct
:a-slot (integer)
:another-slot (integer)))
(lambda (x) (= (slot-value x ’a-slot) 0))
:regression-id some-test-with-regression-cases
:regression-file my-regression-test-file)))
“‘

This will (most likely) discover a failing case, shrink it, and append the following code to ‘my-regression-test-file‘:

“‘lisp
(REGRESSION-CASE SOME-TEST-WITH-REGRESSION-CASES "#S(A-STRUCT :A-SLOT 1 :ANOTHER-SLOT 0)")
“‘

Regression cases must be given a ‘regression-id‘ to know which ‘check-it‘ form they apply to. It’s probably simplest just to tag them with the same symbol you used to name the test. (This makes your test code a little more redundant, but it keeps check-it simple and framework-agnostic.) Although generators are meant to generate data with readable print representations, some objects (like structs) cannot be dumped into FASL files, so regression cases are encoded as strings which are read after the file is loaded in order to delay their construction.

It is recommended that you output your regression cases to a special file that initially contains only the line ‘(in-package :same-package-as-test-package)‘ and is loaded as part of the same system as your tests. Then the next time you run a check-it test, all the regression cases will be checked before any random cases are generated, which should hopefully light a fire under your ass to fix bugs you’ve already discovered before you hunt for new ones.

You can also provide a list of explicit inline examples that will also be checked before any random cases are generated using the ‘:examples‘ keyword argument to ‘check-it‘.

Eventually, check-it will be integrated more elegantly with individual test frameworks by extending their APIs. For now, you can reduce code repetition by declaring a file to output regression cases for all ‘regression-id‘s in a given package with ‘(register-package-regression-file :package file)‘, so you don’t have to mention the file in each test.

#### Note on Mapped Generators

All data types constructed with check-it’s essential generators can be successfully converted to readable print representations, but it’s possible that something you create with a mapped generator will produce a data type that can’t. If you want to enable regression cases for tests involving unexternalizable data types, try to find a way to construct those data types within the test body if possible. Eventually, check-it may use a more robust solution for externalization, but this simple method can get you surprisingly far.

## Shrinking

When a generated value fails a test, check-it searches for a simpler value as follows:

An ‘integer‘ generator shrinks toward zero, or if zero is not included in its range, toward the bound in its type spec that has the smaller absolute value.

A ‘real‘ generator doesn’t shrink, because the shrinkage procedure only really makes sense over discrete search spaces.

A ‘list‘ generator shrinks by repeatedly removing elements from the list and/or shrinking individual elements while respecting the type spec of the subgenerator.

An ‘or‘ generator shrinks by shrinking the one generator among its alternatives that was involved in generating the failed value. However, if this generator’s value cannot be shrunk further, and other alternatives available to the ‘or‘ generator specify constant values, then one of those constant values may be substituted instead. So if the generator ‘(or (integer 5) :a-keyword)‘ failed after generating 5 from the ‘integer‘ subgenerator, check-it will attempt to use ‘:a-keyword‘. This opens up more possible shrinkage paths in the overall space defined by the ‘or‘ generator’s parent generators.

Other generators shrink by recursively shrinking their subgenerators while still respecting the overall type spec.

For mapped generators, the subgenerators shrink according to their own internal degrees of freedom, but the mapping is applied to the candidate replacement values from the subgenerators to determine whether resulting composite data structure still fails the test. There’s a bit of a thorny issue here in that check-it doesn’t know for sure whether a simpler value in a subgenerator will really correspond to a simpler value after the mapping is applied. For this reason, good mapping functions should typically specify one-to-one mappings that simply assemble new data structures, and more complicated logic should go in the test body.

For chained generators, the parameterizers are not involved in the shrinking process; the parameterized generator is shrunk according to the parameters it had when it failed the test.

### Note on Destructive Operations

Currently, generators cache their generated values and often make use of them during the shrinking process. If you perform destructive operations on the input to a test function, shrinking may not work correctly. This will be fixed eventually. In the meantime, you can turn off shrinking by giving ‘check-it‘ the keyword argument ‘:shrink-failures nil‘.

Version

0.1.0

Dependencies
Source

check-it.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 check-it/src

Dependency

check-it.asd (file)

Parent

check-it (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Next: , Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 check-it.asd

Location

check-it.asd

Systems

check-it (system)

Packages

check-it-system


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 check-it/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

check-it

Internal Definitions

*system-directory* (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 check-it/src/util.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/util.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 check-it/src/generators.lisp

Dependency

util.lisp (file)

Parent

src (module)

Location

src/generators.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 check-it/src/regenerate.lisp

Dependency

generators.lisp (file)

Parent

src (module)

Location

src/regenerate.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 check-it/src/shrink.lisp

Dependency

regenerate.lisp (file)

Parent

src (module)

Location

src/shrink.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.7 check-it/src/check-it.lisp

Dependency

shrink.lisp (file)

Parent

src (module)

Location

src/check-it.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Files   [Contents][Index]

4.2 Other


Previous: , Up: Other files   [Contents][Index]

4.2.1 check-it/check-it.asd

Parent

check-it (system)

Location

check-it.asd


Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 check-it-system

Source

check-it.asd

Use List

Previous: , Up: Packages   [Contents][Index]

5.2 check-it

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *bias-sensitivity*
Package

check-it

Source

generators.lisp (file)

Special Variable: *check-it-output*
Package

check-it

Source

check-it.lisp (file)

Special Variable: *list-size*
Package

check-it

Source

generators.lisp (file)

Special Variable: *list-size-decay*
Package

check-it

Source

generators.lisp (file)

Special Variable: *num-trials*
Package

check-it

Source

generators.lisp (file)

Special Variable: *recursive-bias-decay*
Package

check-it

Source

generators.lisp (file)

Special Variable: *size*
Package

check-it

Source

generators.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: check-it GENERATOR TEST &key EXAMPLES SHRINK-FAILURES RANDOM-STATE REGRESSION-ID REGRESSION-FILE

Macro for performing a randomized test run.

Package

check-it

Source

check-it.lisp (file)

Macro: def-generator NAME LAMBDA-LIST &body BODY

Define a new, possibly recursive, generator type.

Package

check-it

Source

generators.lisp (file)

Macro: def-genex-macro NAME LAMBDA-LIST &body BODY

Define a code template to expand wherever a generator expression could appear.

Package

check-it

Source

generators.lisp (file)

Macro: generator EXP

Macro to establish the beginning of a section of code in the generator DSL.

Package

check-it

Source

generators.lisp (file)

Macro: regression-case &key NAME DATUM TIMESTAMP
Package

check-it

Source

check-it.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: register-package-regression-file PACKAGE REGRESSION-FILE

Register a file to be used for saving all regression cases for a package.

Package

check-it

Source

check-it.lisp (file)

Function: shrink-and-trap-errors VALUE TEST
Package

check-it

Source

shrink.lisp (file)

Function: wrap-test-for-error-reporting TEST

Return a function capturing unhandled errors in TEST as data.

Package

check-it

Source

check-it.lisp (file)

Function: wrap-test-for-shrinking TEST

Return a function treating unhandled errors in TEST as failures.

Package

check-it

Source

check-it.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Generic functions

Generic Function: cached-generator OBJECT
Generic Function: (setf cached-generator) NEW-VALUE OBJECT
Package

check-it

Methods
Method: cached-generator (CHAINED-GENERATOR chained-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf cached-generator) NEW-VALUE (CHAINED-GENERATOR chained-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: cached-generator (OR-GENERATOR or-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf cached-generator) NEW-VALUE (OR-GENERATOR or-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: cached-value OBJECT
Generic Function: (setf cached-value) NEW-VALUE OBJECT
Package

check-it

Methods
Method: cached-value (GENERATOR generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf cached-value) NEW-VALUE (GENERATOR generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: generate GENERATOR

Produce and cache a random value from a generator object.

Package

check-it

Source

generators.lisp (file)

Methods
Method: generate (GENERATOR custom-generator) around
Method: generate (GENERATOR custom-generator)
Method: generate (GENERATOR chained-generator)
Method: generate (GENERATOR mapped-generator)
Method: generate (GENERATOR struct-generator)
Method: generate (GENERATOR guard-generator)
Method: generate (GENERATOR char-generator)
Method: generate (GENERATOR real-generator)
Method: generate (GENERATOR bool-generator)
Method: generate (GENERATOR int-generator)
Method: generate (GENERATOR or-generator)
Method: generate (GENERATOR tuple-generator)
Method: generate (GENERATOR string-generator)
Method: generate (GENERATOR list-generator)
Method: generate (GENERATOR generator) around
Method: generate GENERATOR

Treat non-generators as constants.

Generic Function: regenerate GENERATOR

Regenerate a value equivalent to the previous value created with GENERATE.

Package

check-it

Source

regenerate.lisp (file)

Methods
Method: regenerate (GENERATOR custom-generator)
Method: regenerate (GENERATOR guard-generator)
Method: regenerate (GENERATOR chained-generator)
Method: regenerate (GENERATOR mapped-generator)
Method: regenerate (GENERATOR struct-generator)
Method: regenerate (GENERATOR string-generator)
Method: regenerate (GENERATOR char-generator)
Method: regenerate (GENERATOR real-generator)
Method: regenerate (GENERATOR int-generator)
Method: regenerate (GENERATOR or-generator)
Method: regenerate (GENERATOR tuple-generator)
Method: regenerate (GENERATOR list-generator)
Method: regenerate (GENERATOR generator) around
Method: regenerate GENERATOR

Treat non-generators as constants.

Generic Function: shrink VALUE TEST

Find a simpler value that fails the TEST.

Package

check-it

Source

shrink.lisp (file)

Methods
Method: shrink (VALUE custom-generator) TEST
Method: shrink (VALUE chained-generator) TEST
Method: shrink (VALUE mapped-generator) TEST
Method: shrink (VALUE guard-generator) TEST
Method: shrink (VALUE struct-generator) TEST
Method: shrink (VALUE tuple-generator) TEST
Method: shrink (VALUE list-generator) TEST
Method: shrink (VALUE or-generator) TEST

If any of the untried alternatives are constant, they can be trivially considered to constitute a search space of a complexity smaller than or equal to that of the alternative that was originally tried.

Method: shrink (VALUE real-generator) TEST
Method: shrink (VALUE char-generator) TEST
Method: shrink (VALUE int-generator) TEST
Method: shrink (VALUE string-generator) TEST
Method: shrink (VALUE list) TEST
Method: shrink (VALUE real) TEST
Method: shrink (VALUE integer) TEST
Method: shrink (VALUE structure-object) TEST
Method: shrink VALUE TEST
Generic Function: slot-generators OBJECT
Generic Function: (setf slot-generators) NEW-VALUE OBJECT
Package

check-it

Methods
Method: slot-generators (STRUCT-GENERATOR struct-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf slot-generators) NEW-VALUE (STRUCT-GENERATOR struct-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: slot-names OBJECT
Generic Function: (setf slot-names) NEW-VALUE OBJECT
Package

check-it

Methods
Method: slot-names (STRUCT-GENERATOR struct-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf slot-names) NEW-VALUE (STRUCT-GENERATOR struct-generator)

automatically generated writer method

Source

generators.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Classes

Class: chained-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct methods
Direct slots
Slot: pre-generators
Initargs

:pre-generators

Readers

pre-generators (generic function)

Writers

(setf pre-generators) (generic function)

Slot: generator-function
Initargs

:generator-function

Readers

generator-function (generic function)

Writers

(setf generator-function) (generic function)

Slot: cached-generator
Initargs

:cached-generator

Readers

cached-generator (generic function)

Writers

(setf cached-generator) (generic function)

Class: char-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

simple-generator (class)

Direct methods
Direct slots
Slot: lower-limit
Initargs

:lower-limit

Initform

(quote *)

Readers

lower-limit (generic function)

Writers

(setf lower-limit) (generic function)

Slot: upper-limit
Initargs

:upper-limit

Initform

(quote *)

Readers

upper-limit (generic function)

Writers

(setf upper-limit) (generic function)

Slot: generator-function
Readers

generator-function (generic function)

Writers

(setf generator-function) (generic function)

Class: generator ()

Abstract base class for all generators. Not meant to be instantiated.

Package

check-it

Source

generators.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: cached-value
Initargs

:cached-value

Readers

cached-value (generic function)

Writers

(setf cached-value) (generic function)

Class: guard-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct methods
Direct slots
Slot: guard
Initargs

:guard

Readers

guard (generic function)

Writers

(setf guard) (generic function)

Slot: sub-generator
Initargs

:sub-generator

Readers

sub-generator (generic function)

Writers

(setf sub-generator) (generic function)

Class: int-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

simple-generator (class)

Direct methods
Direct slots
Slot: lower-limit
Initargs

:lower-limit

Initform

(quote *)

Readers

lower-limit (generic function)

Writers

(setf lower-limit) (generic function)

Slot: upper-limit
Initargs

:upper-limit

Initform

(quote *)

Readers

upper-limit (generic function)

Writers

(setf upper-limit) (generic function)

Slot: generator-function
Readers

generator-function (generic function)

Writers

(setf generator-function) (generic function)

Slot: shrinker-predicate
Readers

shrinker-predicate (generic function)

Writers

(setf shrinker-predicate) (generic function)

Class: list-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct subclasses

string-generator (class)

Direct methods
Direct slots
Slot: generator-function
Initargs

:generator-function

Readers

generator-function (generic function)

Writers

(setf generator-function) (generic function)

Slot: sub-generators
Initargs

:sub-generators

Readers

sub-generators (generic function)

Writers

(setf sub-generators) (generic function)

Slot: min-length
Initargs

:min-length

Initform

0

Readers

min-length (generic function)

Writers

(setf min-length) (generic function)

Slot: max-length
Initargs

:max-length

Initform

(1- most-positive-fixnum)

Readers

max-length (generic function)

Writers

(setf max-length) (generic function)

Class: mapped-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct methods
Direct slots
Slot: sub-generators
Initargs

:sub-generators

Readers

sub-generators (generic function)

Writers

(setf sub-generators) (generic function)

Slot: mapping
Initargs

:mapping

Readers

mapping (generic function)

Writers

(setf mapping) (generic function)

Class: or-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct methods
Direct slots
Slot: cached-generator
Initargs

:cached-generator

Readers

cached-generator (generic function)

Writers

(setf cached-generator) (generic function)

Slot: sub-generators
Initargs

:sub-generators

Readers

sub-generators (generic function)

Writers

(setf sub-generators) (generic function)

Class: real-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

simple-generator (class)

Direct methods
Direct slots
Slot: lower-limit
Initargs

:lower-limit

Initform

(quote *)

Readers

lower-limit (generic function)

Writers

(setf lower-limit) (generic function)

Slot: upper-limit
Initargs

:upper-limit

Initform

(quote *)

Readers

upper-limit (generic function)

Writers

(setf upper-limit) (generic function)

Slot: generator-function
Readers

generator-function (generic function)

Writers

(setf generator-function) (generic function)

Class: regression-case ()
Package

check-it

Source

check-it.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Slot: datum
Initargs

:datum

Readers

datum (generic function)

Slot: timestamp
Initargs

:timestamp

Readers

timestamp (generic function)

Class: string-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

list-generator (class)

Direct methods
Direct slots
Slot: cached-str-list
Readers

cached-str-list (generic function)

Writers

(setf cached-str-list) (generic function)

Class: tuple-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct methods
Direct slots
Slot: sub-generators
Initargs

:sub-generators

Readers

sub-generators (generic function)

Writers

(setf sub-generators) (generic function)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *package-regression-files*
Package

check-it

Source

check-it.lisp (file)

Special Variable: *system-directory*
Package

check-it

Source

package.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Macros

Macro: destructuring-lambda PARAMS &body BODY

Pass the arguments of a destructuring lambda list to a function body.

Package

check-it

Source

util.lisp (file)

Macro: with-obvious-accessors ACCESSORS INSTANCE &body BODY

Like WITH-ACCESSORS but with the brevity of WITH-SLOTS.

Package

check-it

Source

util.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Functions

Function: char-generator-function LOW HIGH

Return a function for producing random chars uniformly with appropriate bounds.

Package

check-it

Source

generators.lisp (file)

Function: check-it% TEST-FORM GENERATOR TEST &key EXAMPLES SHRINK-FAILURES RANDOM-STATE REGRESSION-ID REGRESSION-FILE
Package

check-it

Source

check-it.lisp (file)

Function: choose-generator GENERATORS

Make a weighted choice to pick one of a number of generators.
This function, along with COMPUTE-WEIGHTS, uses an algorithm that basically generalizes a sigmoidal probabilistic activation function from 2 to N possible outputs.

Package

check-it

Source

generators.lisp (file)

Function: compute-weights NUMBERS SENSITIVITY
Package

check-it

Source

generators.lisp (file)

Function: copy-structure-and-slots STRUCTURE SLOT-NAMES
Package

check-it

Source

shrink.lisp (file)

Function: expand-generator EXP
Package

check-it

Source

generators.lisp (file)

Function: extract-params-from-lambda-list LAMBDA-LIST

Return a list of the names of all parameters in an ordinary lambda list.

Package

check-it

Source

util.lisp (file)

Function: int-generator-function LOW HIGH

Return a function for producing random integers uniformly with appropriate bounds.

Package

check-it

Source

generators.lisp (file)

Function: int-shrinker-predicate LOW HIGH

Return a function for testing the validity of shrinking integers with appropriate bounds.

Package

check-it

Source

generators.lisp (file)

Function: join-list CHAR-LIST

Join the given CHAR-LIST of characters to a string. ’(#a #b #b) => "abc"

Package

check-it

Source

util.lisp (file)

Function: make-list-generator-form GENERATOR-FUNCTION &rest KEYS &key MIN-LENGTH MAX-LENGTH LENGTH
Package

check-it

Source

generators.lisp (file)

Function: make-string-generator-form &rest KEYS &key MIN-LENGTH MAX-LENGTH LENGTH
Package

check-it

Source

generators.lisp (file)

Function: make-struct-from-type TYPE-NAME
Package

check-it

Source

util.lisp (file)

Function: random-element LIST
Package

check-it

Source

generators.lisp (file)

Function: random-uniform ()
Package

check-it

Source

generators.lisp (file)

Function: real-generator-function LOW HIGH

Return a function for producing random reals uniformly with appropriate bounds.

Package

check-it

Source

generators.lisp (file)

Function: regression-case% NAME DATUM TIMESTAMP
Package

check-it

Source

check-it.lisp (file)

Function: remove-nth N LIST
Package

check-it

Source

shrink.lisp (file)

Function: shrink-int VALUE TEST PREV BEST
Package

check-it

Source

shrink.lisp (file)

Function: shrink-list VALUE TEST
Package

check-it

Source

shrink.lisp (file)

Function: shrink-list-generator VALUE TEST
Package

check-it

Source

shrink.lisp (file)

Function: slot-definition-name SLOT
Package

check-it

Source

generators.lisp (file)

Function: smaller NUM1 NUM2
Package

check-it

Source

shrink.lisp (file)

Function: string-generator-function ()
Package

check-it

Source

generators.lisp (file)

Function: struct-slot-names STRUCT
Package

check-it

Source

generators.lisp (file)

Function: struct-type-slot-names STRUCT-TYPE
Package

check-it

Source

generators.lisp (file)

Function: success RESULT
Package

check-it

Source

shrink.lisp (file)

Function: write-regression-case NAME DATA-STRING

Produce code for a regression case to be written to a file.

Package

check-it

Source

check-it.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Generic functions

Generic Function: bias GENERATOR
Package

check-it

Methods
Method: bias GENERATOR
Source

generators.lisp (file)

Generic Function: cached-str-list OBJECT
Generic Function: (setf cached-str-list) NEW-VALUE OBJECT
Package

check-it

Methods
Method: cached-str-list (STRING-GENERATOR string-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf cached-str-list) NEW-VALUE (STRING-GENERATOR string-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: call-with-adjusted-bias GENERATOR PROCEED

Strategies for managing growth of recursive generators.

Package

check-it

Source

generators.lisp (file)

Methods
Method: call-with-adjusted-bias (GENERATOR custom-generator) PROCEED
Generic Function: datum OBJECT
Package

check-it

Methods
Method: datum (REGRESSION-CASE regression-case)

automatically generated reader method

Source

check-it.lisp (file)

Generic Function: errored RESULT
Package

check-it

Source

check-it.lisp (file)

Methods
Method: errored RESULT
Method: errored (RESULT reified-error)
Generic Function: generator-function OBJECT
Generic Function: (setf generator-function) NEW-VALUE OBJECT
Package

check-it

Methods
Method: generator-function (CHAINED-GENERATOR chained-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf generator-function) NEW-VALUE (CHAINED-GENERATOR chained-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: generator-function (LIST-GENERATOR list-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf generator-function) NEW-VALUE (LIST-GENERATOR list-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: generator-function (CHAR-GENERATOR char-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf generator-function) NEW-VALUE (CHAR-GENERATOR char-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: generator-function (REAL-GENERATOR real-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf generator-function) NEW-VALUE (REAL-GENERATOR real-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: generator-function (INT-GENERATOR int-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf generator-function) NEW-VALUE (INT-GENERATOR int-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: kind OBJECT
Generic Function: (setf kind) NEW-VALUE OBJECT
Package

check-it

Methods
Method: kind (CUSTOM-GENERATOR custom-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf kind) NEW-VALUE (CUSTOM-GENERATOR custom-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: lower-limit OBJECT
Generic Function: (setf lower-limit) NEW-VALUE OBJECT
Package

check-it

Methods
Method: lower-limit (CHAR-GENERATOR char-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf lower-limit) NEW-VALUE (CHAR-GENERATOR char-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: lower-limit (REAL-GENERATOR real-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf lower-limit) NEW-VALUE (REAL-GENERATOR real-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: lower-limit (INT-GENERATOR int-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf lower-limit) NEW-VALUE (INT-GENERATOR int-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: mapping OBJECT
Generic Function: (setf mapping) NEW-VALUE OBJECT
Package

check-it

Methods
Method: mapping (MAPPED-GENERATOR mapped-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf mapping) NEW-VALUE (MAPPED-GENERATOR mapped-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: max-length OBJECT
Generic Function: (setf max-length) NEW-VALUE OBJECT
Package

check-it

Methods
Method: max-length (LIST-GENERATOR list-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf max-length) NEW-VALUE (LIST-GENERATOR list-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: min-length OBJECT
Generic Function: (setf min-length) NEW-VALUE OBJECT
Package

check-it

Methods
Method: min-length (LIST-GENERATOR list-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf min-length) NEW-VALUE (LIST-GENERATOR list-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: name OBJECT
Package

check-it

Methods
Method: name (REGRESSION-CASE regression-case)

automatically generated reader method

Source

check-it.lisp (file)

Generic Function: pre-generators OBJECT
Generic Function: (setf pre-generators) NEW-VALUE OBJECT
Package

check-it

Methods
Method: pre-generators (CHAINED-GENERATOR chained-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf pre-generators) NEW-VALUE (CHAINED-GENERATOR chained-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: recursive-depth OBJECT
Generic Function: (setf recursive-depth) NEW-VALUE OBJECT
Package

check-it

Methods
Method: recursive-depth (CUSTOM-GENERATOR custom-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf recursive-depth) NEW-VALUE (CUSTOM-GENERATOR custom-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: shrinker-predicate OBJECT
Generic Function: (setf shrinker-predicate) NEW-VALUE OBJECT
Package

check-it

Methods
Method: shrinker-predicate (INT-GENERATOR int-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf shrinker-predicate) NEW-VALUE (INT-GENERATOR int-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: slot-keywords OBJECT
Generic Function: (setf slot-keywords) NEW-VALUE OBJECT
Package

check-it

Methods
Method: slot-keywords (STRUCT-GENERATOR struct-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf slot-keywords) NEW-VALUE (STRUCT-GENERATOR struct-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: struct-type OBJECT
Generic Function: (setf struct-type) NEW-VALUE OBJECT
Package

check-it

Methods
Method: struct-type (STRUCT-GENERATOR struct-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf struct-type) NEW-VALUE (STRUCT-GENERATOR struct-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: sub-generator OBJECT
Generic Function: (setf sub-generator) NEW-VALUE OBJECT
Package

check-it

Methods
Method: sub-generator (CUSTOM-GENERATOR custom-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf sub-generator) NEW-VALUE (CUSTOM-GENERATOR custom-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: sub-generator (GUARD-GENERATOR guard-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf sub-generator) NEW-VALUE (GUARD-GENERATOR guard-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: sub-generators OBJECT
Generic Function: (setf sub-generators) NEW-VALUE OBJECT
Package

check-it

Methods
Method: sub-generators (MAPPED-GENERATOR mapped-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf sub-generators) NEW-VALUE (MAPPED-GENERATOR mapped-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: sub-generators (OR-GENERATOR or-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf sub-generators) NEW-VALUE (OR-GENERATOR or-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: sub-generators (TUPLE-GENERATOR tuple-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf sub-generators) NEW-VALUE (TUPLE-GENERATOR tuple-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: sub-generators (LIST-GENERATOR list-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf sub-generators) NEW-VALUE (LIST-GENERATOR list-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: timestamp OBJECT
Package

check-it

Methods
Method: timestamp (REGRESSION-CASE regression-case)

automatically generated reader method

Source

check-it.lisp (file)

Generic Function: upper-limit OBJECT
Generic Function: (setf upper-limit) NEW-VALUE OBJECT
Package

check-it

Methods
Method: upper-limit (CHAR-GENERATOR char-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf upper-limit) NEW-VALUE (CHAR-GENERATOR char-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: upper-limit (REAL-GENERATOR real-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf upper-limit) NEW-VALUE (REAL-GENERATOR real-generator)

automatically generated writer method

Source

generators.lisp (file)

Method: upper-limit (INT-GENERATOR int-generator)

automatically generated reader method

Source

generators.lisp (file)

Method: (setf upper-limit) NEW-VALUE (INT-GENERATOR int-generator)

automatically generated writer method

Source

generators.lisp (file)

Generic Function: wrapped-error OBJECT
Generic Function: (setf wrapped-error) NEW-VALUE OBJECT
Package

check-it

Methods
Method: wrapped-error (REIFIED-ERROR reified-error)

automatically generated reader method

Source

check-it.lisp (file)

Method: (setf wrapped-error) NEW-VALUE (REIFIED-ERROR reified-error)

automatically generated writer method

Source

check-it.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Classes

Class: bool-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct methods

generate (method)

Class: custom-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct methods
Direct slots
Slot: kind
Initargs

:kind

Readers

kind (generic function)

Writers

(setf kind) (generic function)

Slot: sub-generator
Readers

sub-generator (generic function)

Writers

(setf sub-generator) (generic function)

Slot: recursive-depth
Initform

0

Readers

recursive-depth (generic function)

Writers

(setf recursive-depth) (generic function)

Class: reified-error ()
Package

check-it

Source

check-it.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: wrapped-error
Initargs

:wrapped-error

Readers

wrapped-error (generic function)

Writers

(setf wrapped-error) (generic function)

Class: simple-generator ()

Abstract base class for non-compound generators. Not meant to be instantiated.

Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct subclasses
Class: struct-generator ()
Package

check-it

Source

generators.lisp (file)

Direct superclasses

generator (class)

Direct methods
Direct slots
Slot: struct-type
Initargs

:struct-type

Readers

struct-type (generic function)

Writers

(setf struct-type) (generic function)

Slot: slot-names
Initargs

:slot-names

Readers

slot-names (generic function)

Writers

(setf slot-names) (generic function)

Slot: slot-keywords
Initargs

:slot-keywords

Readers

slot-keywords (generic function)

Writers

(setf slot-keywords) (generic function)

Slot: slot-generators
Initargs

:slot-generators

Readers

slot-generators (generic function)

Writers

(setf slot-generators) (generic function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L   M   O  
Index Entry  Section

C
check-it.asd: The check-it<dot>asd file
check-it/check-it.asd: The check-it/check-it<dot>asd file
check-it/src: The check-it/src module
check-it/src/check-it.lisp: The check-it/src/check-it<dot>lisp file
check-it/src/generators.lisp: The check-it/src/generators<dot>lisp file
check-it/src/package.lisp: The check-it/src/package<dot>lisp file
check-it/src/regenerate.lisp: The check-it/src/regenerate<dot>lisp file
check-it/src/shrink.lisp: The check-it/src/shrink<dot>lisp file
check-it/src/util.lisp: The check-it/src/util<dot>lisp file

F
File, Lisp, check-it.asd: The check-it<dot>asd file
File, Lisp, check-it/src/check-it.lisp: The check-it/src/check-it<dot>lisp file
File, Lisp, check-it/src/generators.lisp: The check-it/src/generators<dot>lisp file
File, Lisp, check-it/src/package.lisp: The check-it/src/package<dot>lisp file
File, Lisp, check-it/src/regenerate.lisp: The check-it/src/regenerate<dot>lisp file
File, Lisp, check-it/src/shrink.lisp: The check-it/src/shrink<dot>lisp file
File, Lisp, check-it/src/util.lisp: The check-it/src/util<dot>lisp file
File, other, check-it/check-it.asd: The check-it/check-it<dot>asd file

L
Lisp File, check-it.asd: The check-it<dot>asd file
Lisp File, check-it/src/check-it.lisp: The check-it/src/check-it<dot>lisp file
Lisp File, check-it/src/generators.lisp: The check-it/src/generators<dot>lisp file
Lisp File, check-it/src/package.lisp: The check-it/src/package<dot>lisp file
Lisp File, check-it/src/regenerate.lisp: The check-it/src/regenerate<dot>lisp file
Lisp File, check-it/src/shrink.lisp: The check-it/src/shrink<dot>lisp file
Lisp File, check-it/src/util.lisp: The check-it/src/util<dot>lisp file

M
Module, check-it/src: The check-it/src module

O
Other File, check-it/check-it.asd: The check-it/check-it<dot>asd file

Jump to:   C   F   L   M   O  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
B   C   D   E   F   G   I   J   K   L   M   N   P   R   S   T   U   W  
Index Entry  Section

(
(setf cached-generator): Exported generic functions
(setf cached-generator): Exported generic functions
(setf cached-generator): Exported generic functions
(setf cached-str-list): Internal generic functions
(setf cached-str-list): Internal generic functions
(setf cached-value): Exported generic functions
(setf cached-value): Exported generic functions
(setf generator-function): Internal generic functions
(setf generator-function): Internal generic functions
(setf generator-function): Internal generic functions
(setf generator-function): Internal generic functions
(setf generator-function): Internal generic functions
(setf generator-function): Internal generic functions
(setf kind): Internal generic functions
(setf kind): Internal generic functions
(setf lower-limit): Internal generic functions
(setf lower-limit): Internal generic functions
(setf lower-limit): Internal generic functions
(setf lower-limit): Internal generic functions
(setf mapping): Internal generic functions
(setf mapping): Internal generic functions
(setf max-length): Internal generic functions
(setf max-length): Internal generic functions
(setf min-length): Internal generic functions
(setf min-length): Internal generic functions
(setf pre-generators): Internal generic functions
(setf pre-generators): Internal generic functions
(setf recursive-depth): Internal generic functions
(setf recursive-depth): Internal generic functions
(setf shrinker-predicate): Internal generic functions
(setf shrinker-predicate): Internal generic functions
(setf slot-generators): Exported generic functions
(setf slot-generators): Exported generic functions
(setf slot-keywords): Internal generic functions
(setf slot-keywords): Internal generic functions
(setf slot-names): Exported generic functions
(setf slot-names): Exported generic functions
(setf struct-type): Internal generic functions
(setf struct-type): Internal generic functions
(setf sub-generator): Internal generic functions
(setf sub-generator): Internal generic functions
(setf sub-generator): Internal generic functions
(setf sub-generators): Internal generic functions
(setf sub-generators): Internal generic functions
(setf sub-generators): Internal generic functions
(setf sub-generators): Internal generic functions
(setf sub-generators): Internal generic functions
(setf upper-limit): Internal generic functions
(setf upper-limit): Internal generic functions
(setf upper-limit): Internal generic functions
(setf upper-limit): Internal generic functions
(setf wrapped-error): Internal generic functions
(setf wrapped-error): Internal generic functions

B
bias: Internal generic functions
bias: Internal generic functions

C
cached-generator: Exported generic functions
cached-generator: Exported generic functions
cached-generator: Exported generic functions
cached-str-list: Internal generic functions
cached-str-list: Internal generic functions
cached-value: Exported generic functions
cached-value: Exported generic functions
call-with-adjusted-bias: Internal generic functions
call-with-adjusted-bias: Internal generic functions
char-generator-function: Internal functions
check-it: Exported macros
check-it%: Internal functions
choose-generator: Internal functions
compute-weights: Internal functions
copy-structure-and-slots: Internal functions

D
datum: Internal generic functions
datum: Internal generic functions
def-generator: Exported macros
def-genex-macro: Exported macros
destructuring-lambda: Internal macros

E
errored: Internal generic functions
errored: Internal generic functions
errored: Internal generic functions
expand-generator: Internal functions
extract-params-from-lambda-list: Internal functions

F
Function, char-generator-function: Internal functions
Function, check-it%: Internal functions
Function, choose-generator: Internal functions
Function, compute-weights: Internal functions
Function, copy-structure-and-slots: Internal functions
Function, expand-generator: Internal functions
Function, extract-params-from-lambda-list: Internal functions
Function, int-generator-function: Internal functions
Function, int-shrinker-predicate: Internal functions
Function, join-list: Internal functions
Function, make-list-generator-form: Internal functions
Function, make-string-generator-form: Internal functions
Function, make-struct-from-type: Internal functions
Function, random-element: Internal functions
Function, random-uniform: Internal functions
Function, real-generator-function: Internal functions
Function, register-package-regression-file: Exported functions
Function, regression-case%: Internal functions
Function, remove-nth: Internal functions
Function, shrink-and-trap-errors: Exported functions
Function, shrink-int: Internal functions
Function, shrink-list: Internal functions
Function, shrink-list-generator: Internal functions
Function, slot-definition-name: Internal functions
Function, smaller: Internal functions
Function, string-generator-function: Internal functions
Function, struct-slot-names: Internal functions
Function, struct-type-slot-names: Internal functions
Function, success: Internal functions
Function, wrap-test-for-error-reporting: Exported functions
Function, wrap-test-for-shrinking: Exported functions
Function, write-regression-case: Internal functions

G
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generate: Exported generic functions
generator: Exported macros
generator-function: Internal generic functions
generator-function: Internal generic functions
generator-function: Internal generic functions
generator-function: Internal generic functions
generator-function: Internal generic functions
generator-function: Internal generic functions
Generic Function, (setf cached-generator): Exported generic functions
Generic Function, (setf cached-str-list): Internal generic functions
Generic Function, (setf cached-value): Exported generic functions
Generic Function, (setf generator-function): Internal generic functions
Generic Function, (setf kind): Internal generic functions
Generic Function, (setf lower-limit): Internal generic functions
Generic Function, (setf mapping): Internal generic functions
Generic Function, (setf max-length): Internal generic functions
Generic Function, (setf min-length): Internal generic functions
Generic Function, (setf pre-generators): Internal generic functions
Generic Function, (setf recursive-depth): Internal generic functions
Generic Function, (setf shrinker-predicate): Internal generic functions
Generic Function, (setf slot-generators): Exported generic functions
Generic Function, (setf slot-keywords): Internal generic functions
Generic Function, (setf slot-names): Exported generic functions
Generic Function, (setf struct-type): Internal generic functions
Generic Function, (setf sub-generator): Internal generic functions
Generic Function, (setf sub-generators): Internal generic functions
Generic Function, (setf upper-limit): Internal generic functions
Generic Function, (setf wrapped-error): Internal generic functions
Generic Function, bias: Internal generic functions
Generic Function, cached-generator: Exported generic functions
Generic Function, cached-str-list: Internal generic functions
Generic Function, cached-value: Exported generic functions
Generic Function, call-with-adjusted-bias: Internal generic functions
Generic Function, datum: Internal generic functions
Generic Function, errored: Internal generic functions
Generic Function, generate: Exported generic functions
Generic Function, generator-function: Internal generic functions
Generic Function, kind: Internal generic functions
Generic Function, lower-limit: Internal generic functions
Generic Function, mapping: Internal generic functions
Generic Function, max-length: Internal generic functions
Generic Function, min-length: Internal generic functions
Generic Function, name: Internal generic functions
Generic Function, pre-generators: Internal generic functions
Generic Function, recursive-depth: Internal generic functions
Generic Function, regenerate: Exported generic functions
Generic Function, shrink: Exported generic functions
Generic Function, shrinker-predicate: Internal generic functions
Generic Function, slot-generators: Exported generic functions
Generic Function, slot-keywords: Internal generic functions
Generic Function, slot-names: Exported generic functions
Generic Function, struct-type: Internal generic functions
Generic Function, sub-generator: Internal generic functions
Generic Function, sub-generators: Internal generic functions
Generic Function, timestamp: Internal generic functions
Generic Function, upper-limit: Internal generic functions
Generic Function, wrapped-error: Internal generic functions

I
int-generator-function: Internal functions
int-shrinker-predicate: Internal functions

J
join-list: Internal functions

K
kind: Internal generic functions
kind: Internal generic functions

L
lower-limit: Internal generic functions
lower-limit: Internal generic functions
lower-limit: Internal generic functions
lower-limit: Internal generic functions

M
Macro, check-it: Exported macros
Macro, def-generator: Exported macros
Macro, def-genex-macro: Exported macros
Macro, destructuring-lambda: Internal macros
Macro, generator: Exported macros
Macro, regression-case: Exported macros
Macro, with-obvious-accessors: Internal macros
make-list-generator-form: Internal functions
make-string-generator-form: Internal functions
make-struct-from-type: Internal functions
mapping: Internal generic functions
mapping: Internal generic functions
max-length: Internal generic functions
max-length: Internal generic functions
Method, (setf cached-generator): Exported generic functions
Method, (setf cached-generator): Exported generic functions
Method, (setf cached-str-list): Internal generic functions
Method, (setf cached-value): Exported generic functions
Method, (setf generator-function): Internal generic functions
Method, (setf generator-function): Internal generic functions
Method, (setf generator-function): Internal generic functions
Method, (setf generator-function): Internal generic functions
Method, (setf generator-function): Internal generic functions
Method, (setf kind): Internal generic functions
Method, (setf lower-limit): Internal generic functions
Method, (setf lower-limit): Internal generic functions
Method, (setf lower-limit): Internal generic functions
Method, (setf mapping): Internal generic functions
Method, (setf max-length): Internal generic functions
Method, (setf min-length): Internal generic functions
Method, (setf pre-generators): Internal generic functions
Method, (setf recursive-depth): Internal generic functions
Method, (setf shrinker-predicate): Internal generic functions
Method, (setf slot-generators): Exported generic functions
Method, (setf slot-keywords): Internal generic functions
Method, (setf slot-names): Exported generic functions
Method, (setf struct-type): Internal generic functions
Method, (setf sub-generator): Internal generic functions
Method, (setf sub-generator): Internal generic functions
Method, (setf sub-generators): Internal generic functions
Method, (setf sub-generators): Internal generic functions
Method, (setf sub-generators): Internal generic functions
Method, (setf sub-generators): Internal generic functions
Method, (setf upper-limit): Internal generic functions
Method, (setf upper-limit): Internal generic functions
Method, (setf upper-limit): Internal generic functions
Method, (setf wrapped-error): Internal generic functions
Method, bias: Internal generic functions
Method, cached-generator: Exported generic functions
Method, cached-generator: Exported generic functions
Method, cached-str-list: Internal generic functions
Method, cached-value: Exported generic functions
Method, call-with-adjusted-bias: Internal generic functions
Method, datum: Internal generic functions
Method, errored: Internal generic functions
Method, errored: Internal generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generate: Exported generic functions
Method, generator-function: Internal generic functions
Method, generator-function: Internal generic functions
Method, generator-function: Internal generic functions
Method, generator-function: Internal generic functions
Method, generator-function: Internal generic functions
Method, kind: Internal generic functions
Method, lower-limit: Internal generic functions
Method, lower-limit: Internal generic functions
Method, lower-limit: Internal generic functions
Method, mapping: Internal generic functions
Method, max-length: Internal generic functions
Method, min-length: Internal generic functions
Method, name: Internal generic functions
Method, pre-generators: Internal generic functions
Method, recursive-depth: Internal generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, regenerate: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrink: Exported generic functions
Method, shrinker-predicate: Internal generic functions
Method, slot-generators: Exported generic functions
Method, slot-keywords: Internal generic functions
Method, slot-names: Exported generic functions
Method, struct-type: Internal generic functions
Method, sub-generator: Internal generic functions
Method, sub-generator: Internal generic functions
Method, sub-generators: Internal generic functions
Method, sub-generators: Internal generic functions
Method, sub-generators: Internal generic functions
Method, sub-generators: Internal generic functions
Method, timestamp: Internal generic functions
Method, upper-limit: Internal generic functions
Method, upper-limit: Internal generic functions
Method, upper-limit: Internal generic functions
Method, wrapped-error: Internal generic functions
min-length: Internal generic functions
min-length: Internal generic functions

N
name: Internal generic functions
name: Internal generic functions

P
pre-generators: Internal generic functions
pre-generators: Internal generic functions

R
random-element: Internal functions
random-uniform: Internal functions
real-generator-function: Internal functions
recursive-depth: Internal generic functions
recursive-depth: Internal generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
regenerate: Exported generic functions
register-package-regression-file: Exported functions
regression-case: Exported macros
regression-case%: Internal functions
remove-nth: Internal functions

S
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink: Exported generic functions
shrink-and-trap-errors: Exported functions
shrink-int: Internal functions
shrink-list: Internal functions
shrink-list-generator: Internal functions
shrinker-predicate: Internal generic functions
shrinker-predicate: Internal generic functions
slot-definition-name: Internal functions
slot-generators: Exported generic functions
slot-generators: Exported generic functions
slot-keywords: Internal generic functions
slot-keywords: Internal generic functions
slot-names: Exported generic functions
slot-names: Exported generic functions
smaller: Internal functions
string-generator-function: Internal functions
struct-slot-names: Internal functions
struct-type: Internal generic functions
struct-type: Internal generic functions
struct-type-slot-names: Internal functions
sub-generator: Internal generic functions
sub-generator: Internal generic functions
sub-generator: Internal generic functions
sub-generators: Internal generic functions
sub-generators: Internal generic functions
sub-generators: Internal generic functions
sub-generators: Internal generic functions
sub-generators: Internal generic functions
success: Internal functions

T
timestamp: Internal generic functions
timestamp: Internal generic functions

U
upper-limit: Internal generic functions
upper-limit: Internal generic functions
upper-limit: Internal generic functions
upper-limit: Internal generic functions

W
with-obvious-accessors: Internal macros
wrap-test-for-error-reporting: Exported functions
wrap-test-for-shrinking: Exported functions
wrapped-error: Internal generic functions
wrapped-error: Internal generic functions
write-regression-case: Internal functions

Jump to:   (  
B   C   D   E   F   G   I   J   K   L   M   N   P   R   S   T   U   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
C   D   G   K   L   M   N   P   R   S   T   U   W  
Index Entry  Section

*
*bias-sensitivity*: Exported special variables
*check-it-output*: Exported special variables
*list-size*: Exported special variables
*list-size-decay*: Exported special variables
*num-trials*: Exported special variables
*package-regression-files*: Internal special variables
*recursive-bias-decay*: Exported special variables
*size*: Exported special variables
*system-directory*: Internal special variables

C
cached-generator: Exported classes
cached-generator: Exported classes
cached-str-list: Exported classes
cached-value: Exported classes

D
datum: Exported classes

G
generator-function: Exported classes
generator-function: Exported classes
generator-function: Exported classes
generator-function: Exported classes
generator-function: Exported classes
guard: Exported classes

K
kind: Internal classes

L
lower-limit: Exported classes
lower-limit: Exported classes
lower-limit: Exported classes

M
mapping: Exported classes
max-length: Exported classes
min-length: Exported classes

N
name: Exported classes

P
pre-generators: Exported classes

R
recursive-depth: Internal classes

S
shrinker-predicate: Exported classes
Slot, cached-generator: Exported classes
Slot, cached-generator: Exported classes
Slot, cached-str-list: Exported classes
Slot, cached-value: Exported classes
Slot, datum: Exported classes
Slot, generator-function: Exported classes
Slot, generator-function: Exported classes
Slot, generator-function: Exported classes
Slot, generator-function: Exported classes
Slot, generator-function: Exported classes
Slot, guard: Exported classes
Slot, kind: Internal classes
Slot, lower-limit: Exported classes
Slot, lower-limit: Exported classes
Slot, lower-limit: Exported classes
Slot, mapping: Exported classes
Slot, max-length: Exported classes
Slot, min-length: Exported classes
Slot, name: Exported classes
Slot, pre-generators: Exported classes
Slot, recursive-depth: Internal classes
Slot, shrinker-predicate: Exported classes
Slot, slot-generators: Internal classes
Slot, slot-keywords: Internal classes
Slot, slot-names: Internal classes
Slot, struct-type: Internal classes
Slot, sub-generator: Exported classes
Slot, sub-generator: Internal classes
Slot, sub-generators: Exported classes
Slot, sub-generators: Exported classes
Slot, sub-generators: Exported classes
Slot, sub-generators: Exported classes
Slot, timestamp: Exported classes
Slot, upper-limit: Exported classes
Slot, upper-limit: Exported classes
Slot, upper-limit: Exported classes
Slot, wrapped-error: Internal classes
slot-generators: Internal classes
slot-keywords: Internal classes
slot-names: Internal classes
Special Variable, *bias-sensitivity*: Exported special variables
Special Variable, *check-it-output*: Exported special variables
Special Variable, *list-size*: Exported special variables
Special Variable, *list-size-decay*: Exported special variables
Special Variable, *num-trials*: Exported special variables
Special Variable, *package-regression-files*: Internal special variables
Special Variable, *recursive-bias-decay*: Exported special variables
Special Variable, *size*: Exported special variables
Special Variable, *system-directory*: Internal special variables
struct-type: Internal classes
sub-generator: Exported classes
sub-generator: Internal classes
sub-generators: Exported classes
sub-generators: Exported classes
sub-generators: Exported classes
sub-generators: Exported classes

T
timestamp: Exported classes

U
upper-limit: Exported classes
upper-limit: Exported classes
upper-limit: Exported classes

W
wrapped-error: Internal classes

Jump to:   *  
C   D   G   K   L   M   N   P   R   S   T   U   W  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   B   C   G   I   L   M   O   P   R   S   T  
Index Entry  Section

B
bool-generator: Internal classes

C
chained-generator: Exported classes
char-generator: Exported classes
check-it: The check-it system
check-it: The check-it package
check-it-system: The check-it-system package
Class, bool-generator: Internal classes
Class, chained-generator: Exported classes
Class, char-generator: Exported classes
Class, custom-generator: Internal classes
Class, generator: Exported classes
Class, guard-generator: Exported classes
Class, int-generator: Exported classes
Class, list-generator: Exported classes
Class, mapped-generator: Exported classes
Class, or-generator: Exported classes
Class, real-generator: Exported classes
Class, regression-case: Exported classes
Class, reified-error: Internal classes
Class, simple-generator: Internal classes
Class, string-generator: Exported classes
Class, struct-generator: Internal classes
Class, tuple-generator: Exported classes
custom-generator: Internal classes

G
generator: Exported classes
guard-generator: Exported classes

I
int-generator: Exported classes

L
list-generator: Exported classes

M
mapped-generator: Exported classes

O
or-generator: Exported classes

P
Package, check-it: The check-it package
Package, check-it-system: The check-it-system package

R
real-generator: Exported classes
regression-case: Exported classes
reified-error: Internal classes

S
simple-generator: Internal classes
string-generator: Exported classes
struct-generator: Internal classes
System, check-it: The check-it system

T
tuple-generator: Exported classes

Jump to:   B   C   G   I   L   M   O   P   R   S   T