The check-it Reference Manual

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 4.0 beta 2 "William Riker" on Thu Sep 15 03:29:30 2022 GMT+0.

Table of Contents


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.


2 Systems

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


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

2.1 check-it

A randomized property-based testing tool for Common Lisp.

Author

Kyle Littler

Home Page

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

License

LLGPL

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
  • alexandria (system).
  • closer-mop (system).
  • optima (system).
Source

check-it.asd.

Child Component

src (module).


3 Modules

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


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

3.1 check-it/src

Source

check-it.asd.

Parent Component

check-it (system).

Child Components

4 Files

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


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

4.1 Lisp


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

4.1.1 check-it/check-it.asd

Source

check-it.asd.

Parent Component

check-it (system).

ASDF Systems

check-it.

Packages

check-it-system.


4.1.2 check-it/src/package.lisp

Source

check-it.asd.

Parent Component

src (module).

Packages

check-it.

Internals

*system-directory* (special variable).


4.1.3 check-it/src/util.lisp

Dependency

package.lisp (file).

Source

check-it.asd.

Parent Component

src (module).

Internals

4.1.4 check-it/src/generators.lisp

Dependency

util.lisp (file).

Source

check-it.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.5 check-it/src/regenerate.lisp

Dependency

generators.lisp (file).

Source

check-it.asd.

Parent Component

src (module).

Public Interface

regenerate (generic function).


4.1.6 check-it/src/shrink.lisp

Dependency

regenerate.lisp (file).

Source

check-it.asd.

Parent Component

src (module).

Public Interface
Internals

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

Dependency

shrink.lisp (file).

Source

check-it.asd.

Parent Component

src (module).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


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

5.1 check-it

Source

package.lisp.

Use List
  • alexandria.
  • common-lisp.
  • optima.
Public Interface
Internals

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

5.2 check-it-system

Source

check-it.asd.

Use List
  • asdf/interface.
  • common-lisp.

6 Definitions

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


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

6.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.1 Special variables

Special Variable: *bias-sensitivity*
Package

check-it.

Source

generators.lisp.

Special Variable: *check-it-output*
Package

check-it.

Source

check-it.lisp.

Special Variable: *list-size*
Package

check-it.

Source

generators.lisp.

Special Variable: *list-size-decay*
Package

check-it.

Source

generators.lisp.

Special Variable: *num-trials*
Package

check-it.

Source

generators.lisp.

Special Variable: *recursive-bias-decay*
Package

check-it.

Source

generators.lisp.

Special Variable: *size*
Package

check-it.

Source

generators.lisp.


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.

Macro: def-generator (name lambda-list &body body)

Define a new, possibly recursive, generator type.

Package

check-it.

Source

generators.lisp.

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.

Macro: generator (exp)

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

Package

check-it.

Source

generators.lisp.

Macro: regression-case (&key name datum timestamp)
Package

check-it.

Source

check-it.lisp.


6.1.3 Ordinary 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.

Function: shrink-and-trap-errors (value test)
Package

check-it.

Source

shrink.lisp.

Function: wrap-test-for-error-reporting (test)

Return a function capturing unhandled errors in TEST as data.

Package

check-it.

Source

check-it.lisp.

Function: wrap-test-for-shrinking (test)

Return a function treating unhandled errors in TEST as failures.

Package

check-it.

Source

check-it.lisp.


6.1.4 Generic functions

Generic Reader: cached-generator (object)
Package

check-it.

Methods
Reader Method: cached-generator ((chained-generator chained-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

cached-generator.

Reader Method: cached-generator ((or-generator or-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

cached-generator.

Generic Writer: (setf cached-generator) (object)
Package

check-it.

Methods
Writer Method: (setf cached-generator) ((chained-generator chained-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

cached-generator.

Writer Method: (setf cached-generator) ((or-generator or-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

cached-generator.

Generic Reader: cached-value (object)
Package

check-it.

Methods
Reader Method: cached-value ((generator generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

cached-value.

Generic Writer: (setf cached-value) (object)
Package

check-it.

Methods
Writer Method: (setf cached-value) ((generator generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

cached-value.

Generic Function: generate (generator)

Produce and cache a random value from a generator object.

Package

check-it.

Source

generators.lisp.

Methods
Method: generate :around ((generator custom-generator))
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 :around ((generator generator))
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.

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 :around ((generator generator))
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.

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 Reader: slot-generators (object)
Package

check-it.

Methods
Reader Method: slot-generators ((struct-generator struct-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

slot-generators.

Generic Writer: (setf slot-generators) (object)
Package

check-it.

Methods
Writer Method: (setf slot-generators) ((struct-generator struct-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

slot-generators.

Generic Reader: slot-names (object)
Package

check-it.

Methods
Reader Method: slot-names ((struct-generator struct-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

slot-names.

Generic Writer: (setf slot-names) (object)
Package

check-it.

Methods
Writer Method: (setf slot-names) ((struct-generator struct-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

slot-names.


6.1.5 Standalone methods

Writer Method: (setf guard) ((guard-generator guard-generator))

automatically generated writer method

Package

optima.

Source

generators.lisp.

Target Slot

guard.

Reader Method: guard ((guard-generator guard-generator))

automatically generated reader method

Package

optima.

Source

generators.lisp.

Target Slot

guard.

Method: initialize-instance :after ((instance real-generator) &rest initargs)
Source

generators.lisp.

Method: initialize-instance :after ((instance int-generator) &rest initargs)
Source

generators.lisp.

Method: initialize-instance :after ((instance char-generator) &rest initargs)
Source

generators.lisp.

Method: initialize-instance :after ((generator string-generator) &rest initargs)
Source

generators.lisp.


6.1.6 Classes

Class: chained-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct methods
Direct slots
Slot: pre-generators
Initargs

:pre-generators

Readers

pre-generators.

Writers

(setf pre-generators).

Slot: generator-function
Initargs

:generator-function

Readers

generator-function.

Writers

(setf generator-function).

Slot: cached-generator
Initargs

:cached-generator

Readers

cached-generator.

Writers

(setf cached-generator).

Class: char-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

simple-generator.

Direct methods
Direct slots
Slot: lower-limit
Initform

(quote *)

Initargs

:lower-limit

Readers

lower-limit.

Writers

(setf lower-limit).

Slot: upper-limit
Initform

(quote *)

Initargs

:upper-limit

Readers

upper-limit.

Writers

(setf upper-limit).

Slot: generator-function
Readers

generator-function.

Writers

(setf generator-function).

Class: generator

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

Package

check-it.

Source

generators.lisp.

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

:cached-value

Readers

cached-value.

Writers

(setf cached-value).

Class: guard-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct methods
Direct slots
Slot: guard
Package

optima.

Initargs

:guard

Readers

guard.

Writers

(setf guard).

Slot: sub-generator
Initargs

:sub-generator

Readers

sub-generator.

Writers

(setf sub-generator).

Class: int-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

simple-generator.

Direct methods
Direct slots
Slot: lower-limit
Initform

(quote *)

Initargs

:lower-limit

Readers

lower-limit.

Writers

(setf lower-limit).

Slot: upper-limit
Initform

(quote *)

Initargs

:upper-limit

Readers

upper-limit.

Writers

(setf upper-limit).

Slot: generator-function
Readers

generator-function.

Writers

(setf generator-function).

Slot: shrinker-predicate
Readers

shrinker-predicate.

Writers

(setf shrinker-predicate).

Class: list-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct subclasses

string-generator.

Direct methods
Direct slots
Slot: generator-function
Initargs

:generator-function

Readers

generator-function.

Writers

(setf generator-function).

Slot: sub-generators
Initargs

:sub-generators

Readers

sub-generators.

Writers

(setf sub-generators).

Slot: min-length
Initform

0

Initargs

:min-length

Readers

min-length.

Writers

(setf min-length).

Slot: max-length
Initform

(1- most-positive-fixnum)

Initargs

:max-length

Readers

max-length.

Writers

(setf max-length).

Class: mapped-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct methods
Direct slots
Slot: sub-generators
Initargs

:sub-generators

Readers

sub-generators.

Writers

(setf sub-generators).

Slot: mapping
Initargs

:mapping

Readers

mapping.

Writers

(setf mapping).

Class: or-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct methods
Direct slots
Slot: cached-generator
Initargs

:cached-generator

Readers

cached-generator.

Writers

(setf cached-generator).

Slot: sub-generators
Initargs

:sub-generators

Readers

sub-generators.

Writers

(setf sub-generators).

Class: real-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

simple-generator.

Direct methods
Direct slots
Slot: lower-limit
Initform

(quote *)

Initargs

:lower-limit

Readers

lower-limit.

Writers

(setf lower-limit).

Slot: upper-limit
Initform

(quote *)

Initargs

:upper-limit

Readers

upper-limit.

Writers

(setf upper-limit).

Slot: generator-function
Readers

generator-function.

Writers

(setf generator-function).

Class: regression-case
Package

check-it.

Source

check-it.lisp.

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

This slot is read-only.

Slot: datum
Initargs

:datum

Readers

datum.

Writers

This slot is read-only.

Slot: timestamp
Initargs

:timestamp

Readers

timestamp.

Writers

This slot is read-only.

Class: string-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

list-generator.

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

cached-str-list.

Writers

(setf cached-str-list).

Class: tuple-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct methods
Direct slots
Slot: sub-generators
Initargs

:sub-generators

Readers

sub-generators.

Writers

(setf sub-generators).


6.2 Internals


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

6.2.1 Special variables

Special Variable: *package-regression-files*
Package

check-it.

Source

check-it.lisp.

Special Variable: *system-directory*
Package

check-it.

Source

package.lisp.


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.

Macro: with-obvious-accessors (accessors instance &body body)

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

Package

check-it.

Source

util.lisp.


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

6.2.3 Ordinary functions

Function: char-generator-function (low high)

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

Package

check-it.

Source

generators.lisp.

Function: check-it% (test-form generator test &key examples shrink-failures random-state regression-id regression-file)
Package

check-it.

Source

check-it.lisp.

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.

Function: compute-weights (numbers sensitivity)
Package

check-it.

Source

generators.lisp.

Function: copy-structure-and-slots (structure slot-names)
Package

check-it.

Source

shrink.lisp.

Function: expand-generator (exp)
Package

check-it.

Source

generators.lisp.

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.

Function: int-generator-function (low high)

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

Package

check-it.

Source

generators.lisp.

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.

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.

Function: make-list-generator-form (generator-function &rest keys &key min-length max-length length)
Package

check-it.

Source

generators.lisp.

Function: make-string-generator-form (&rest keys &key min-length max-length length)
Package

check-it.

Source

generators.lisp.

Function: make-struct-from-type (type-name)
Package

check-it.

Source

util.lisp.

Function: random-element (list)
Package

check-it.

Source

generators.lisp.

Function: random-uniform ()
Package

check-it.

Source

generators.lisp.

Function: real-generator-function (low high)

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

Package

check-it.

Source

generators.lisp.

Function: regression-case% (name datum timestamp)
Package

check-it.

Source

check-it.lisp.

Function: remove-nth (n list)
Package

check-it.

Source

shrink.lisp.

Function: shrink-int (value test prev best)
Package

check-it.

Source

shrink.lisp.

Function: shrink-list (value test)
Package

check-it.

Source

shrink.lisp.

Function: shrink-list-generator (value test)
Package

check-it.

Source

shrink.lisp.

Function: slot-definition-name (slot)
Package

check-it.

Source

generators.lisp.

Function: smaller (num1 num2)
Package

check-it.

Source

shrink.lisp.

Function: string-generator-function ()
Package

check-it.

Source

generators.lisp.

Function: struct-slot-names (struct)
Package

check-it.

Source

generators.lisp.

Function: struct-type-slot-names (struct-type)
Package

check-it.

Source

generators.lisp.

Function: success (result)
Package

check-it.

Source

shrink.lisp.

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.


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

6.2.4 Generic functions

Generic Function: bias (generator)
Package

check-it.

Methods
Method: bias (generator)
Source

generators.lisp.

Generic Reader: cached-str-list (object)
Package

check-it.

Methods
Reader Method: cached-str-list ((string-generator string-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

cached-str-list.

Generic Writer: (setf cached-str-list) (object)
Package

check-it.

Methods
Writer Method: (setf cached-str-list) ((string-generator string-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

cached-str-list.

Generic Function: call-with-adjusted-bias (generator proceed)

Strategies for managing growth of recursive generators.

Package

check-it.

Source

generators.lisp.

Methods
Method: call-with-adjusted-bias ((generator custom-generator) proceed)
Generic Reader: datum (object)
Package

check-it.

Methods
Reader Method: datum ((regression-case regression-case))

automatically generated reader method

Source

check-it.lisp.

Target Slot

datum.

Generic Function: errored (result)
Package

check-it.

Source

check-it.lisp.

Methods
Method: errored (result)
Method: errored ((result reified-error))
Generic Reader: generator-function (object)
Package

check-it.

Methods
Reader Method: generator-function ((chained-generator chained-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

generator-function.

Reader Method: generator-function ((list-generator list-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

generator-function.

Reader Method: generator-function ((char-generator char-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

generator-function.

Reader Method: generator-function ((real-generator real-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

generator-function.

Reader Method: generator-function ((int-generator int-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

generator-function.

Generic Writer: (setf generator-function) (object)
Package

check-it.

Methods
Writer Method: (setf generator-function) ((chained-generator chained-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

generator-function.

Writer Method: (setf generator-function) ((list-generator list-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

generator-function.

Writer Method: (setf generator-function) ((char-generator char-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

generator-function.

Writer Method: (setf generator-function) ((real-generator real-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

generator-function.

Writer Method: (setf generator-function) ((int-generator int-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

generator-function.

Generic Reader: kind (object)
Package

check-it.

Methods
Reader Method: kind ((custom-generator custom-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

kind.

Generic Writer: (setf kind) (object)
Package

check-it.

Methods
Writer Method: (setf kind) ((custom-generator custom-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

kind.

Generic Reader: lower-limit (object)
Package

check-it.

Methods
Reader Method: lower-limit ((char-generator char-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

lower-limit.

Reader Method: lower-limit ((real-generator real-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

lower-limit.

Reader Method: lower-limit ((int-generator int-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

lower-limit.

Generic Writer: (setf lower-limit) (object)
Package

check-it.

Methods
Writer Method: (setf lower-limit) ((char-generator char-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

lower-limit.

Writer Method: (setf lower-limit) ((real-generator real-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

lower-limit.

Writer Method: (setf lower-limit) ((int-generator int-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

lower-limit.

Generic Reader: mapping (object)
Package

check-it.

Methods
Reader Method: mapping ((mapped-generator mapped-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

mapping.

Generic Writer: (setf mapping) (object)
Package

check-it.

Methods
Writer Method: (setf mapping) ((mapped-generator mapped-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

mapping.

Generic Reader: max-length (object)
Package

check-it.

Methods
Reader Method: max-length ((list-generator list-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

max-length.

Generic Writer: (setf max-length) (object)
Package

check-it.

Methods
Writer Method: (setf max-length) ((list-generator list-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

max-length.

Generic Reader: min-length (object)
Package

check-it.

Methods
Reader Method: min-length ((list-generator list-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

min-length.

Generic Writer: (setf min-length) (object)
Package

check-it.

Methods
Writer Method: (setf min-length) ((list-generator list-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

min-length.

Generic Reader: name (object)
Package

check-it.

Methods
Reader Method: name ((regression-case regression-case))

automatically generated reader method

Source

check-it.lisp.

Target Slot

name.

Generic Reader: pre-generators (object)
Package

check-it.

Methods
Reader Method: pre-generators ((chained-generator chained-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

pre-generators.

Generic Writer: (setf pre-generators) (object)
Package

check-it.

Methods
Writer Method: (setf pre-generators) ((chained-generator chained-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

pre-generators.

Generic Reader: recursive-depth (object)
Package

check-it.

Methods
Reader Method: recursive-depth ((custom-generator custom-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

recursive-depth.

Generic Writer: (setf recursive-depth) (object)
Package

check-it.

Methods
Writer Method: (setf recursive-depth) ((custom-generator custom-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

recursive-depth.

Generic Reader: shrinker-predicate (object)
Package

check-it.

Methods
Reader Method: shrinker-predicate ((int-generator int-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

shrinker-predicate.

Generic Writer: (setf shrinker-predicate) (object)
Package

check-it.

Methods
Writer Method: (setf shrinker-predicate) ((int-generator int-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

shrinker-predicate.

Generic Reader: slot-keywords (object)
Package

check-it.

Methods
Reader Method: slot-keywords ((struct-generator struct-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

slot-keywords.

Generic Writer: (setf slot-keywords) (object)
Package

check-it.

Methods
Writer Method: (setf slot-keywords) ((struct-generator struct-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

slot-keywords.

Generic Reader: struct-type (object)
Package

check-it.

Methods
Reader Method: struct-type ((struct-generator struct-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

struct-type.

Generic Writer: (setf struct-type) (object)
Package

check-it.

Methods
Writer Method: (setf struct-type) ((struct-generator struct-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

struct-type.

Generic Reader: sub-generator (object)
Package

check-it.

Methods
Reader Method: sub-generator ((custom-generator custom-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

sub-generator.

Reader Method: sub-generator ((guard-generator guard-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

sub-generator.

Generic Writer: (setf sub-generator) (object)
Package

check-it.

Methods
Writer Method: (setf sub-generator) ((custom-generator custom-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

sub-generator.

Writer Method: (setf sub-generator) ((guard-generator guard-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

sub-generator.

Generic Reader: sub-generators (object)
Package

check-it.

Methods
Reader Method: sub-generators ((mapped-generator mapped-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

sub-generators.

Reader Method: sub-generators ((or-generator or-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

sub-generators.

Reader Method: sub-generators ((tuple-generator tuple-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

sub-generators.

Reader Method: sub-generators ((list-generator list-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

sub-generators.

Generic Writer: (setf sub-generators) (object)
Package

check-it.

Methods
Writer Method: (setf sub-generators) ((mapped-generator mapped-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

sub-generators.

Writer Method: (setf sub-generators) ((or-generator or-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

sub-generators.

Writer Method: (setf sub-generators) ((tuple-generator tuple-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

sub-generators.

Writer Method: (setf sub-generators) ((list-generator list-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

sub-generators.

Generic Reader: timestamp (object)
Package

check-it.

Methods
Reader Method: timestamp ((regression-case regression-case))

automatically generated reader method

Source

check-it.lisp.

Target Slot

timestamp.

Generic Reader: upper-limit (object)
Package

check-it.

Methods
Reader Method: upper-limit ((char-generator char-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

upper-limit.

Reader Method: upper-limit ((real-generator real-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

upper-limit.

Reader Method: upper-limit ((int-generator int-generator))

automatically generated reader method

Source

generators.lisp.

Target Slot

upper-limit.

Generic Writer: (setf upper-limit) (object)
Package

check-it.

Methods
Writer Method: (setf upper-limit) ((char-generator char-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

upper-limit.

Writer Method: (setf upper-limit) ((real-generator real-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

upper-limit.

Writer Method: (setf upper-limit) ((int-generator int-generator))

automatically generated writer method

Source

generators.lisp.

Target Slot

upper-limit.

Generic Reader: wrapped-error (object)
Package

check-it.

Methods
Reader Method: wrapped-error ((reified-error reified-error))

automatically generated reader method

Source

check-it.lisp.

Target Slot

wrapped-error.

Generic Writer: (setf wrapped-error) (object)
Package

check-it.

Methods
Writer Method: (setf wrapped-error) ((reified-error reified-error))

automatically generated writer method

Source

check-it.lisp.

Target Slot

wrapped-error.


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

6.2.5 Classes

Class: bool-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct methods

generate.

Class: custom-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct methods
Direct slots
Slot: kind
Initargs

:kind

Readers

kind.

Writers

(setf kind).

Slot: sub-generator
Readers

sub-generator.

Writers

(setf sub-generator).

Slot: recursive-depth
Initform

0

Readers

recursive-depth.

Writers

(setf recursive-depth).

Class: reified-error
Package

check-it.

Source

check-it.lisp.

Direct methods
Direct slots
Slot: wrapped-error
Initargs

:wrapped-error

Readers

wrapped-error.

Writers

(setf wrapped-error).

Class: simple-generator

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

Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct subclasses
Class: struct-generator
Package

check-it.

Source

generators.lisp.

Direct superclasses

generator.

Direct methods
Direct slots
Slot: struct-type
Initargs

:struct-type

Readers

struct-type.

Writers

(setf struct-type).

Slot: slot-names
Initargs

:slot-names

Readers

slot-names.

Writers

(setf slot-names).

Slot: slot-keywords
Initargs

:slot-keywords

Readers

slot-keywords.

Writers

(setf slot-keywords).

Slot: slot-generators
Initargs

:slot-generators

Readers

slot-generators.

Writers

(setf slot-generators).


Appendix A Indexes


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

A.1 Concepts


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): Public generic functions
(setf cached-generator): Public generic functions
(setf cached-generator): Public generic functions
(setf cached-str-list): Private generic functions
(setf cached-str-list): Private generic functions
(setf cached-value): Public generic functions
(setf cached-value): Public generic functions
(setf generator-function): Private generic functions
(setf generator-function): Private generic functions
(setf generator-function): Private generic functions
(setf generator-function): Private generic functions
(setf generator-function): Private generic functions
(setf generator-function): Private generic functions
(setf guard): Public standalone methods
(setf kind): Private generic functions
(setf kind): Private generic functions
(setf lower-limit): Private generic functions
(setf lower-limit): Private generic functions
(setf lower-limit): Private generic functions
(setf lower-limit): Private generic functions
(setf mapping): Private generic functions
(setf mapping): Private generic functions
(setf max-length): Private generic functions
(setf max-length): Private generic functions
(setf min-length): Private generic functions
(setf min-length): Private generic functions
(setf pre-generators): Private generic functions
(setf pre-generators): Private generic functions
(setf recursive-depth): Private generic functions
(setf recursive-depth): Private generic functions
(setf shrinker-predicate): Private generic functions
(setf shrinker-predicate): Private generic functions
(setf slot-generators): Public generic functions
(setf slot-generators): Public generic functions
(setf slot-keywords): Private generic functions
(setf slot-keywords): Private generic functions
(setf slot-names): Public generic functions
(setf slot-names): Public generic functions
(setf struct-type): Private generic functions
(setf struct-type): Private generic functions
(setf sub-generator): Private generic functions
(setf sub-generator): Private generic functions
(setf sub-generator): Private generic functions
(setf sub-generators): Private generic functions
(setf sub-generators): Private generic functions
(setf sub-generators): Private generic functions
(setf sub-generators): Private generic functions
(setf sub-generators): Private generic functions
(setf upper-limit): Private generic functions
(setf upper-limit): Private generic functions
(setf upper-limit): Private generic functions
(setf upper-limit): Private generic functions
(setf wrapped-error): Private generic functions
(setf wrapped-error): Private generic functions

B
bias: Private generic functions
bias: Private generic functions

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

D
datum: Private generic functions
datum: Private generic functions
def-generator: Public macros
def-genex-macro: Public macros
destructuring-lambda: Private macros

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

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

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

I
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
int-generator-function: Private ordinary functions
int-shrinker-predicate: Private ordinary functions

J
join-list: Private ordinary functions

K
kind: Private generic functions
kind: Private generic functions

L
lower-limit: Private generic functions
lower-limit: Private generic functions
lower-limit: Private generic functions
lower-limit: Private generic functions

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

N
name: Private generic functions
name: Private generic functions

P
pre-generators: Private generic functions
pre-generators: Private generic functions

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

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

T
timestamp: Private generic functions
timestamp: Private generic functions

U
upper-limit: Private generic functions
upper-limit: Private generic functions
upper-limit: Private generic functions
upper-limit: Private generic functions

W
with-obvious-accessors: Private macros
wrap-test-for-error-reporting: Public ordinary functions
wrap-test-for-shrinking: Public ordinary functions
wrapped-error: Private generic functions
wrapped-error: Private generic functions
write-regression-case: Private ordinary 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*: Public special variables
*check-it-output*: Public special variables
*list-size*: Public special variables
*list-size-decay*: Public special variables
*num-trials*: Public special variables
*package-regression-files*: Private special variables
*recursive-bias-decay*: Public special variables
*size*: Public special variables
*system-directory*: Private special variables

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

D
datum: Public classes

G
generator-function: Public classes
generator-function: Public classes
generator-function: Public classes
generator-function: Public classes
generator-function: Public classes
guard: Public classes

K
kind: Private classes

L
lower-limit: Public classes
lower-limit: Public classes
lower-limit: Public classes

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

N
name: Public classes

P
pre-generators: Public classes

R
recursive-depth: Private classes

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

T
timestamp: Public classes

U
upper-limit: Public classes
upper-limit: Public classes
upper-limit: Public classes

W
wrapped-error: Private 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   F   G   I   L   M   O   P   R   S   T   U  
Index Entry  Section

B
bool-generator: Private classes

C
chained-generator: Public classes
char-generator: Public classes
check-it: The check-it system
check-it: The check-it package
check-it-system: The check-it-system package
check-it.asd: The check-it/check-it․asd file
check-it.lisp: The check-it/src/check-it․lisp file
Class, bool-generator: Private classes
Class, chained-generator: Public classes
Class, char-generator: Public classes
Class, custom-generator: Private classes
Class, generator: Public classes
Class, guard-generator: Public classes
Class, int-generator: Public classes
Class, list-generator: Public classes
Class, mapped-generator: Public classes
Class, or-generator: Public classes
Class, real-generator: Public classes
Class, regression-case: Public classes
Class, reified-error: Private classes
Class, simple-generator: Private classes
Class, string-generator: Public classes
Class, struct-generator: Private classes
Class, tuple-generator: Public classes
custom-generator: Private classes

F
File, check-it.asd: The check-it/check-it․asd file
File, check-it.lisp: The check-it/src/check-it․lisp file
File, generators.lisp: The check-it/src/generators․lisp file
File, package.lisp: The check-it/src/package․lisp file
File, regenerate.lisp: The check-it/src/regenerate․lisp file
File, shrink.lisp: The check-it/src/shrink․lisp file
File, util.lisp: The check-it/src/util․lisp file

G
generator: Public classes
generators.lisp: The check-it/src/generators․lisp file
guard-generator: Public classes

I
int-generator: Public classes

L
list-generator: Public classes

M
mapped-generator: Public classes
Module, src: The check-it/src module

O
or-generator: Public classes

P
Package, check-it: The check-it package
Package, check-it-system: The check-it-system package
package.lisp: The check-it/src/package․lisp file

R
real-generator: Public classes
regenerate.lisp: The check-it/src/regenerate․lisp file
regression-case: Public classes
reified-error: Private classes

S
shrink.lisp: The check-it/src/shrink․lisp file
simple-generator: Private classes
src: The check-it/src module
string-generator: Public classes
struct-generator: Private classes
System, check-it: The check-it system

T
tuple-generator: Public classes

U
util.lisp: The check-it/src/util․lisp file

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