The lisp-unit Reference Manual

This is the lisp-unit Reference Manual, version 1.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 17:09:37 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 lisp-unit

Common Lisp library that supports unit testing.

Author

Thomas M. Hermann <>

License

MIT

Version

1.0.0

Source

lisp-unit.asd.

Child Components

3 Modules

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


3.1 lisp-unit/extensions

Dependency

lisp-unit.lisp (file).

Source

lisp-unit.asd.

Parent Component

lisp-unit (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 lisp-unit/lisp-unit.asd

Source

lisp-unit.asd.

Parent Component

lisp-unit (system).

ASDF Systems

lisp-unit.


4.1.2 lisp-unit/lisp-unit.lisp

Source

lisp-unit.asd.

Parent Component

lisp-unit (system).

Packages

lisp-unit.

Public Interface
Internals

4.1.3 lisp-unit/extensions/rational.lisp

Source

lisp-unit.asd.

Parent Component

extensions (module).

Public Interface
Internals

%seq-rational-equal (function).


4.1.4 lisp-unit/extensions/floating-point.lisp

Source

lisp-unit.asd.

Parent Component

extensions (module).

Public Interface
Internals

4.1.5 lisp-unit/extensions/test-anything-protocol.lisp

Source

lisp-unit.asd.

Parent Component

extensions (module).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


5.1 lisp-unit

Source

lisp-unit.lisp.

Use List

common-lisp.

Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Special variables

Special Variable: *epsilon*

Set the error epsilon if the defaults are not acceptable.

Package

lisp-unit.

Source

floating-point.lisp.

Special Variable: *measure*
Package

lisp-unit.

Source

floating-point.lisp.

Special Variable: *print-errors*

Print error messages if non-NIL.

Package

lisp-unit.

Source

lisp-unit.lisp.

Special Variable: *print-failures*

Print failure messages if non-NIL.

Package

lisp-unit.

Source

lisp-unit.lisp.

Special Variable: *print-summary*

Print a summary of the pass, fail, and error count if non-nil.

Package

lisp-unit.

Source

lisp-unit.lisp.

Special Variable: *significant-figures*

Default to 4 significant figures.

Package

lisp-unit.

Source

floating-point.lisp.

Special Variable: *summarize-results*

Summarize all of the unit test results.

Package

lisp-unit.

Source

lisp-unit.lisp.


6.1.2 Macros

Macro: assert-eq (expected form &rest extras)

Assert whether expected and form are EQ.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-eql (expected form &rest extras)

Assert whether expected and form are EQL.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-equal (expected form &rest extras)

Assert whether expected and form are EQUAL.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-equality (test expected form &rest extras)

Assert whether expected and form are equal according to test.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-equalp (expected form &rest extras)

Assert whether expected and form are EQUALP.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-error (condition form &rest extras)

Assert whether form signals condition.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-expands (expansion form &rest extras)

Assert whether form expands to expansion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-false (form &rest extras)

Assert whether the form is false.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-float-equal (expected form &rest extras)
Package

lisp-unit.

Source

floating-point.lisp.

Macro: assert-nil (form &rest extras)

Assert whether the form is false.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-norm-equal (expected form &rest extras)
Package

lisp-unit.

Source

floating-point.lisp.

Macro: assert-number-equal (expected form &rest extras)
Package

lisp-unit.

Source

floating-point.lisp.

Macro: assert-numerical-equal (expected form &rest extras)
Package

lisp-unit.

Source

floating-point.lisp.

Macro: assert-prints (output form &rest extras)

Assert whether printing the form generates the output.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: assert-rational-equal (expected form &rest extras)
Package

lisp-unit.

Source

rational.lisp.

Macro: assert-sigfig-equal (expected form &rest extras)
Package

lisp-unit.

Source

floating-point.lisp.

Macro: assert-true (form &rest extras)

Assert whether the form is true.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: define-test (name &body body)

Store the test in the test database.

Package

lisp-unit.

Source

lisp-unit.lisp.


6.1.3 Ordinary functions

Function: array-error (array1 array2 &key test error-function)

Return a list of the indices and error between the array elements.

Package

lisp-unit.

Source

floating-point.lisp.

Function: complex-random (limit &optional state)

Return a random complex number.

Package

lisp-unit.

Source

floating-point.lisp.

Function: list-tags (&optional package)

Return a list of the tags in package.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: list-tests (&optional package)

Return a list of the tests in package.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: logically-equal (x y)

Return true if x and y are both false or both true.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: make-2d-list (rows columns &key initial-element)

Return a nested list with INITIAL-ELEMENT.

Package

lisp-unit.

Source

floating-point.lisp.

Function: make-random-2d-array (rows columns &optional limit)

Return a 2D array of random numbers.

Package

lisp-unit.

Source

floating-point.lisp.

Function: make-random-2d-list (rows columns &optional limit)

Return a nested list of random numbers.

Package

lisp-unit.

Source

floating-point.lisp.

Function: make-random-list (size &optional limit)

Return a list of random numbers.

Package

lisp-unit.

Source

floating-point.lisp.

Function: number-equal (number1 number2 &optional epsilon type-eq-p)

Return true if the numbers are equal within some epsilon, optionally requiring the types to be identical.

Package

lisp-unit.

Source

floating-point.lisp.

Function: reduce-test-results-dbs (all-results &key merge)

Return a new instance of TEST-RESULTS-DB which contains all of the results in the sequence RESULTS. Any conflicts are handled by the function MERGE.

The lambda list for the MERGE function is

(key value-1 value-2)

where:
KEY is the key which appears at least twice in the sequence RESULTS. VALUE-1 and VALUE-2 are the conflicting values for the given KEY.

If MERGE is NIL, then an error is signalled when a conflict occurs.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: remove-tags (&optional tags package)

Remove individual tags or entire sets.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: remove-tests (&optional names package)

Remove individual tests or entire sets.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: run-tags (&optional tags package)

Run the tests associated with the specified tags in package.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: run-tests (&optional test-names package)

Run the specified tests in package.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: set-equal (list1 list2 &rest initargs &key key test)

Return true if every element of list1 is an element of list2 and vice versa.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: signal-results (&optional flag)

Signal the results for extensibility.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: summarize-results (results &optional stream)

Print a summary of all results to the stream.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: tagged-tests (&optional tags package)

Return a list of the tests associated with the tags.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: test-code (name &optional package)

Returns the code stored for the test name.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: test-documentation (name &optional package)

Return the documentation for the test.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: test-names (test-results-db)

Return a list of the test names in the database.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: use-debugger (&optional flag)

Use the debugger when testing, or not.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: write-tap (test-results &optional stream)

Write the test results to ‘stream‘ in TAP format. Returns the test results.

Package

lisp-unit.

Source

test-anything-protocol.lisp.

Function: write-tap-to-file (test-results path)

write the test results to ‘path‘ in TAP format, overwriting ‘path‘. Returns pathname to the output file

Package

lisp-unit.

Source

test-anything-protocol.lisp.


6.1.4 Generic functions

Generic Function: default-epsilon (value)

Return the default epsilon for the value.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: default-epsilon ((value array))

Return the default epsilon based on the contents of the array.

Method: default-epsilon ((value vector))

Return the default epsilon based on the contents of the vector.

Method: default-epsilon ((value list))

Return the default epsilon based on contents of the list.

Method: default-epsilon ((value complex))

Return a default epsilon value based on the complex type.

Method: default-epsilon ((value float))

Return a default epsilon value based on the floating point type.

Generic Reader: error-tests (object)
Package

lisp-unit.

Methods
Reader Method: error-tests ((test-results-db test-results-db))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

error-tests.

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

lisp-unit.

Methods
Writer Method: (setf error-tests) ((test-results-db test-results-db))

automatically generated writer method

Source

lisp-unit.lisp.

Target Slot

error-tests.

Generic Reader: failed-tests (object)
Package

lisp-unit.

Methods
Reader Method: failed-tests ((test-results-db test-results-db))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

failed-tests.

Generic Writer: (setf failed-tests) (object)
Package

lisp-unit.

Methods
Writer Method: (setf failed-tests) ((test-results-db test-results-db))

automatically generated writer method

Source

lisp-unit.lisp.

Target Slot

failed-tests.

Generic Function: float-equal (data1 data2 &optional epsilon)

Return true if the floating point data is equal.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: float-equal ((data1 array) (data2 array) &optional epsilon)

Return true if the arrays are equal in length and element-wise comparison of the relative error is less than epsilon.

Method: float-equal ((data1 vector) (data2 vector) &optional epsilon)

Return true if the vectors are equal in length and element-wise comparison of the relative error is less than epsilon.

Method: float-equal ((data1 vector) (data2 list) &optional epsilon)

Return true if the vector and the list are equal in length and element-wise comparison of the relative error is less than epsilon.

Method: float-equal ((data1 list) (data2 vector) &optional epsilon)

Return true if the vector and the list are equal in length and element-wise comparison of the relative error is less than epsilon.

Method: float-equal ((data1 list) (data2 list) &optional epsilon)

Return true if the lists are equal in length and element-wise comparison of the relative error is less than epsilon.

Method: float-equal ((data1 complex) (data2 complex) &optional epsilon)

Return true if the relative error between data1 and data2 is less than epsilon.

Method: float-equal ((data1 complex) (data2 float) &optional epsilon)

Return true if the relative error between data1 and data2 is less than epsilon.

Method: float-equal ((data1 float) (data2 complex) &optional epsilon)

Return true if the relative error between data1 and data2 is less than epsilon.

Method: float-equal ((data1 rational) (data2 float) &optional epsilon)

Return true if the relative error between data1 and data2 is less than epsilon.

Method: float-equal ((data1 float) (data2 rational) &optional epsilon)

Return true if the relative error between data1 and data2 is less than epsilon.

Method: float-equal ((data1 float) (data2 float) &optional epsilon)

Return true if the relative error between data1 and data2 is less than epsilon.

Generic Reader: missing-tests (object)
Package

lisp-unit.

Methods
Reader Method: missing-tests ((test-results-db test-results-db))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

missing-tests.

Generic Writer: (setf missing-tests) (object)
Package

lisp-unit.

Methods
Writer Method: (setf missing-tests) ((test-results-db test-results-db))

automatically generated writer method

Source

lisp-unit.lisp.

Target Slot

missing-tests.

Generic Function: norm (data &optional measure)

Return the element-wise norm of the data.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: norm ((data array) &optional measure)

Return the entrywise norm of the array according to the measure.

Method: norm ((data vector) &optional measure)

Return the norm of the vector according to the measure.

Method: norm ((data list) &optional measure)

Return the norm of the list according to the measure.

Generic Function: norm-equal (data1 data2 &optional epsilon measure)

Return true if the norm of the data is equal.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: norm-equal ((data1 array) (data2 array) &optional epsilon measure)

Return true if the arrays are equal in length and the relative error norm is less than epsilon.

Method: norm-equal ((data1 vector) (data2 vector) &optional epsilon measure)

Return true if the vectors are equal in length and the relative error norm is less than epsilon.

Method: norm-equal ((data1 vector) (data2 list) &optional epsilon measure)

Return true if the vector and the list are equal in length and the relative error norm is less than epsilon.

Method: norm-equal ((data1 list) (data2 vector) &optional epsilon measure)

Return true if the vector and the list are equal in length and the relative error norm is less than epsilon.

Method: norm-equal ((data1 list) (data2 list) &optional epsilon measure)

Return true if the lists are equal in length and the relative error norm is less than epsilon.

Generic Function: numerical-equal (result1 result2 &key test)

Return true if the results are numerically equal according to :TEST.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: numerical-equal ((result1 array) (result2 array) &key test)

Return true if the arrays are equal in dimension and each element is equal according to :TEST.

Method: numerical-equal ((result1 vector) (result2 list) &key test)

Return true if every element of the list is equla to the corresponding element of the vector.

Method: numerical-equal ((result1 list) (result2 vector) &key test)

Return true if every element of the list is equal to the corresponding element of the vector.

Method: numerical-equal ((result1 vector) (result2 vector) &key test)

Return true if the vectors are equal in length and each element is equal according to :TEST.

Method: numerical-equal ((result1 list) (result2 list) &key test)

Return true if the lists are equal in length and each element is equal according to :TEST.

Method: numerical-equal ((result1 number) (result2 number) &key test)

Return true if the the numbers are equal according to :TEST.

Generic Function: print-errors (result &optional stream)

Print the error condition.

Package

lisp-unit.

Source

lisp-unit.lisp.

Methods
Method: print-errors ((results test-results-db) &optional stream)

Print all of the error tests.

Method: print-errors ((result test-result) &optional stream)

Print the error condition.

Generic Function: print-failures (result &optional stream)

Report the results of the failed assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Methods
Method: print-failures ((results test-results-db) &optional stream)

Print all of the failure tests.

Method: print-failures ((result test-result) &optional stream)

Print the failed assertions in the unit test.

Method: print-failures ((result output-result) &optional stream)
Method: print-failures ((result macro-result) &optional stream)
Method: print-failures ((result error-result) &optional stream)
Method: print-failures ((result failure-result) &optional stream)
Method: print-failures :around ((result failure-result) &optional stream)

Failure header and footer output.

Generic Function: rational-equal (data1 data2)

Return true if the rational data is equal.

Package

lisp-unit.

Source

rational.lisp.

Methods
Method: rational-equal ((data1 array) (data2 array))

Return true if the arrays are equal in dimension and element-wise equal.

Method: rational-equal ((data1 vector) (data2 vector))

Return true if the vectors are equal in length and element-wise equal.

Method: rational-equal ((data1 vector) (data2 list))

Return true if the vector and the list are equal in length and element-wise equal.

Method: rational-equal ((data1 list) (data2 vector))

Return true if the vector and the list are equal in length and element-wise equal.

Method: rational-equal ((data1 list) (data2 list))

Return true if the lists are equal in length and element-wise equal.

Method: rational-equal ((data1 complex) (data2 complex))

Return true if the complex parts are rational and equal.

Method: rational-equal ((data1 rational) (data2 rational))

Return true if the rational numbers are equal.

Generic Function: relative-error (exact approximate)

Return the relative-error between the 2 quantities.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: relative-error ((exact complex) (approximate complex))

Return the relative error of the complex numbers.

Method: relative-error ((exact complex) (approximate float))

Return the relative error between the float and complex number.

Method: relative-error ((exact float) (approximate complex))

Return the relative error between the float and complex number.

Method: relative-error ((exact float) (approximate float))

Return the error delta between the exact and approximate floating point value.

Generic Function: relative-error-norm (exact approximate &optional measure)

Return the relative error norm

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: relative-error-norm ((exact array) (approximate vector) &optional measure)

Return the relative error norm of the arrays.

Method: relative-error-norm ((exact vector) (approximate vector) &optional measure)

Return the relative error norm of the vectors.

Method: relative-error-norm ((exact vector) (approximate list) &optional measure)

Return the relative error norm of the list and the vector.

Method: relative-error-norm ((exact list) (approximate vector) &optional measure)

Return the relative error norm of the list and the vector.

Method: relative-error-norm ((exact list) (approximate list) &optional measure)

Return the relative error norm of the lists.

Generic Reader: results (condition)
Package

lisp-unit.

Methods
Reader Method: results ((condition test-run-complete))
Source

lisp-unit.lisp.

Target Slot

results.

Generic Function: sigfig-equal (data1 data2 &optional significant-figures)

Return true if the data have equal significant figures.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: sigfig-equal ((data1 array) (data2 array) &optional significant-figures)

Return true if the arrays are equal in length and the element-wise comparison is equal to significant figures.

Method: sigfig-equal ((data1 vector) (data2 vector) &optional significant-figures)

Return true if the vectors are equal in length and the element-wise comparison is equal to significant figures.

Method: sigfig-equal ((data1 list) (data2 vector) &optional significant-figures)

Return true if the list and the vector are equal in length and the element-wise comparison is equal to significant figures.

Method: sigfig-equal ((data1 vector) (data2 list) &optional significant-figures)

Return true if the vector and the list are equal in length and the element-wise comparison is equal to significant figures.

Method: sigfig-equal ((data1 list) (data2 list) &optional significant-figures)

Return true if the lists are equal in length and the element-wise comparison is equal to significant figures.

Method: sigfig-equal ((data1 float) (data2 float) &optional significant-figures)

Return true if the floating point numbers have equal significant figures.

Generic Function: sump (data p)

Return the scaling parameter and the sum of the powers of p of the ~ data.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: sump ((data array) (p real))

Return the scaling parameter and the sum of the powers of p of the ~ array.

Method: sump ((data vector) (p real))

Return the scaling parameter and the sum of the powers of p of the ~ vector.

Method: sump ((data list) (p real))

Return the scaling parameter and the sum of the powers of p of the ~ data.

Generic Function: sumsq (data)

Return the scaling parameter and the sum of the squares of the ~ data.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: sumsq ((data array))

Return the scaling parameter and the sum of the squares of the ~ array.

Method: sumsq ((data vector))

Return the scaling parameter and the sum of the squares of the ~ vector.

Method: sumsq ((data list))

Return the scaling parameter and the sum of the squares of the ~ list.


6.1.5 Standalone methods

Method: print-object ((object test-results-db) stream)

Print the summary counts with the object.

Source

lisp-unit.lisp.


6.1.6 Conditions

Condition: test-run-complete

Signaled when a test run is finished.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

condition.

Direct methods

results.

Direct slots
Slot: results
Initargs

:results

Readers

results.

Writers

This slot is read-only.


6.2 Internals


6.2.1 Special variables

Special Variable: *fail*

The failed assertion results.

Package

lisp-unit.

Source

lisp-unit.lisp.

Special Variable: *pass*

The passed assertion results.

Package

lisp-unit.

Source

lisp-unit.lisp.

Special Variable: *signal-results*

Signal the result if non NIL.

Package

lisp-unit.

Source

lisp-unit.lisp.

Special Variable: *tag-db*

The tag database is simply a hash table.

Package

lisp-unit.

Source

lisp-unit.lisp.

Special Variable: *test-db*

The unit test database is simply a hash table.

Package

lisp-unit.

Source

lisp-unit.lisp.

Special Variable: *use-debugger*

If not NIL, enter the debugger when an error is encountered in an assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.


6.2.2 Macros

Macro: expand-assert (type form body expected extras &key test)

Expand the assertion to the internal format.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: expand-error-form (form)

Wrap the error assertion in HANDLER-CASE.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: expand-extras (extras)

Expand extra forms.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: expand-macro-form (form env)

Expand the macro form once.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: expand-output-form (form)

Capture the output of the form in a string.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: expand-t-or-f (t-or-f form extras)

Expand the true/false assertions to report the arguments.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: with-package-table ((table &optional package create) &body body)

Execute the body only if the package table exists.

Package

lisp-unit.

Source

lisp-unit.lisp.

Macro: with-package-tags ((table &optional package create) &body body)

Execute the body only if the package tags exists.

Package

lisp-unit.

Source

lisp-unit.lisp.


6.2.3 Ordinary functions

Function: %array-error (array1 array2 test errfun)

Return a list of the indices, values and error of the elements that are not equal.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %array-indices (row-major-index dimensions)

Recursively calculate the indices from the row major index.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %complex-float-random (limit &optional state)

Return a random complex float number.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %complex-rational-random (limit &optional state)

Return a random complex rational number.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %expansion-equal (form1 form2)

Descend into the forms checking for equality.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: %float-equal (data1 data2 epsilon)

Return true if the relative error between the data is less than epsilon.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %norm-equal (seq1 seq2 epsilon measure)

Return true if the relative error norm is less than epsilon.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %normalize-float (significand &optional exponent)

Return the normalized floating point number and exponent.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %record-failure (class form actual expected extras test)

Return an instance of the failure result.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: %relative-error (exact approximate)

Return the relative error of the numbers.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %relative-error-norm (exact approximate measure)

Return the relative error norm of the sequences.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %run-all-thunks (&optional package)

Run all of the test thunks in the package.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: %run-thunks (test-names &optional package)

Run the list of test thunks in the package.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: %seq-float-equal (seq1 seq2 epsilon)

Return true if the element-wise comparison of relative error is less than epsilon.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %seq-rational-equal (seq1 seq2)

Return true if the sequences are equal length and at each position the corresponding elements are equal.

Package

lisp-unit.

Source

rational.lisp.

Function: %seq-sigfig-equal (seq1 seq2 significant-figures)

Return true if the element-wise comparison is equal to the specified significant figures.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %sequence-equal (seq1 seq2 test)

Return true if the sequences are equal in length and each element is equal according to :TEST.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %sequence-error (sequence1 sequence2 test error-function)

Return a sequence of the indice and error between the sequences.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %sigfig-equal (float1 float2 significant-figures)

Return true if the floating point numbers have equal significant figures.

Package

lisp-unit.

Source

floating-point.lisp.

Function: %tests-from-all-tags (&optional package)

Return all of the tests that have been tagged.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: %tests-from-tags (tags &optional package)

Return the tests associated with the tags.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: %write-tap-test-result (name test-result i stream)

Output a single test, taking care to ensure the indentation level is the same before and after invocation.

Package

lisp-unit.

Source

test-anything-protocol.lisp.

Function: default-db-merge-function (results new-results)

Signal an error by default if a merge is required.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: internal-assert (type form code-thunk expected-thunk extras test)

Perform the assertion and record the results.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: nappend-test-results-db (results new-results &key merge)

Merge the results of NEW-RESULTS in to RESULTS. Any conflicts between RESULTS and NEW-RESULTS are handled by the function MERGE.

The lambda list for the MERGE functions is

(key results-value new-results-value)

where:
KEY is the key which appears in RESULTS and NEW-RESULTS. RESULTS-VALUE is the value appearing RESULTS. NEW-RESULTS-VALUE is the value appearing in NEW-RESULTS.

If MERGE is NIL, then an error is signalled when a conflict occurs.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: null-tags-warning-report (null-tags-warning stream)

Write the null-tags-warning to the stream.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: null-tests-warning-report (null-tests-warning stream)

Write the null-tests-warning to the stream.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: package-table (package &optional create)
Package

lisp-unit.

Source

lisp-unit.lisp.

Function: package-tags (package &optional create)

Return the tags DB for the package.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: parse-body (body &optional doc tag)

Separate the components of the body.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: print-summary (test-result &optional stream)

Print a summary of the test result.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: record-result (test-name code results)

Run the test code and record the result.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: reset-counters ()

Reset the counters to empty lists.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: run-code (code)

Run the code to test the assertions.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: run-test-thunk (name code)
Package

lisp-unit.

Source

lisp-unit.lisp.

Function: run-time-s (test-result)

calculate the run-time of the test in seconds

Package

lisp-unit.

Source

test-anything-protocol.lisp.

Function: sequence-error (sequence1 sequence2 &key test error-function)

Return a sequence of the indice and error between the sequence elements.

Package

lisp-unit.

Source

floating-point.lisp.

Function: test-name-error-report (test-name-error stream)

Write the test-name-error to the stream.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: test-package (name)

Return the package for storing the test.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: use-debugger-p (condition)

Debug or ignore errors.

Package

lisp-unit.

Source

lisp-unit.lisp.

Function: valid-test-name (name)

Signal a type-error if the test name is not a symbol.

Package

lisp-unit.

Source

lisp-unit.lisp.


6.2.4 Generic functions

Generic Function: %norm (data measure)

Return the norm of the data according to measure.

Package

lisp-unit.

Source

floating-point.lisp.

Methods
Method: %norm ((data vector) (measure (eql :infinity)))

Return the infinity, or maximum, norm of the vector.

Method: %norm ((data list) (measure (eql :infinity)))

Return the infinity, or maximum, norm of the list.

Method: %norm ((data vector) (measure integer))

Return the Euclidean norm of the vector.

Method: %norm ((data list) (measure integer))

Return the Euclidean norm of the list.

Method: %norm ((data vector) (measure (eql 2)))

Return the Euclidean norm of the vector.

Method: %norm ((data list) (measure (eql 2)))

Return the Euclidean norm of the list.

Method: %norm ((data vector) (measure (eql 1)))

Return the Taxicab norm of the vector.

Method: %norm ((data list) (measure (eql 1)))

Return the Taxicab norm of the list.

Generic Reader: actual (object)
Package

lisp-unit.

Methods
Reader Method: actual ((failure-result failure-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

actual.

Generic Function: assert-result (type test expected actual)

Return the result of the assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Methods
Method: assert-result ((type (eql :output)) test expected actual)

Return the result of an output assertion.

Method: assert-result ((type (eql :result)) test expected actual)

Return the result of a result assertion.

Method: assert-result ((type (eql :macro)) test expected actual)

Return the result of a macro assertion.

Method: assert-result ((type (eql :error)) test expected actual)

Return the result of an error assertion.

Method: assert-result ((type (eql :equal)) test expected actual)

Return the result of an equal assertion.

Generic Reader: code (object)
Package

lisp-unit.

Methods
Reader Method: code ((unit-test unit-test))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

code.

Generic Reader: database (object)
Package

lisp-unit.

Methods
Reader Method: database ((test-results-db test-results-db))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

database.

Generic Reader: doc (object)
Package

lisp-unit.

Methods
Reader Method: doc ((unit-test unit-test))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

doc.

Generic Reader: exerr (object)
Package

lisp-unit.

Methods
Reader Method: exerr ((test-results-db test-results-db))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

exerr.

Reader Method: exerr ((test-result test-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

exerr.

Generic Writer: (setf exerr) (object)
Package

lisp-unit.

Methods
Writer Method: (setf exerr) ((test-results-db test-results-db))

automatically generated writer method

Source

lisp-unit.lisp.

Target Slot

exerr.

Generic Reader: expected (object)
Package

lisp-unit.

Methods
Reader Method: expected ((failure-result failure-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

expected.

Generic Reader: extras (object)
Package

lisp-unit.

Methods
Reader Method: extras ((failure-result failure-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

extras.

Generic Reader: fail (object)
Package

lisp-unit.

Methods
Reader Method: fail ((test-results-db test-results-db))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

fail.

Reader Method: fail ((test-result test-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

fail.

Generic Writer: (setf fail) (object)
Package

lisp-unit.

Methods
Writer Method: (setf fail) ((test-results-db test-results-db))

automatically generated writer method

Source

lisp-unit.lisp.

Target Slot

fail.

Generic Reader: form (object)
Package

lisp-unit.

Methods
Reader Method: form ((failure-result failure-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

form.

Generic Reader: name (object)
Package

lisp-unit.

Methods
Reader Method: name ((test-result test-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

name.

Generic Reader: pass (object)
Package

lisp-unit.

Methods
Reader Method: pass ((test-results-db test-results-db))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

pass.

Reader Method: pass ((test-result test-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

pass.

Generic Writer: (setf pass) (object)
Package

lisp-unit.

Methods
Writer Method: (setf pass) ((test-results-db test-results-db))

automatically generated writer method

Source

lisp-unit.lisp.

Target Slot

pass.

Generic Function: record-failure (type form actual expected extras test)

Record the details of the failure.

Package

lisp-unit.

Source

lisp-unit.lisp.

Methods
Method: record-failure ((type (eql :output)) form actual expected extras test)

Return an instance of an output failure result.

Method: record-failure ((type (eql :result)) form actual expected extras test)

Return an instance of a boolean failure result.

Method: record-failure ((type (eql :macro)) form actual expected extras test)

Return an instance of a macro failure result.

Method: record-failure ((type (eql :error)) form actual expected extras test)

Return an instance of an error failure result.

Method: record-failure ((type (eql :equal)) form actual expected extras test)

Return an instance of an equal failure result.

Generic Reader: run-time (object)
Package

lisp-unit.

Methods
Reader Method: run-time ((test-result test-result))

Test run time measured in internal time units

Source

lisp-unit.lisp.

Target Slot

run-time.

Generic Reader: tags-package-name (condition)
Package

lisp-unit.

Methods
Reader Method: tags-package-name ((condition null-tags-warning))
Source

lisp-unit.lisp.

Target Slot

name.

Generic Reader: test (object)
Package

lisp-unit.

Methods
Reader Method: test ((failure-result failure-result))

automatically generated reader method

Source

lisp-unit.lisp.

Target Slot

test.

Generic Reader: tests-package-name (condition)
Package

lisp-unit.

Methods
Reader Method: tests-package-name ((condition null-tests-warning))
Source

lisp-unit.lisp.

Target Slot

name.


6.2.5 Conditions

Condition: null-tags-warning
Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

simple-warning.

Direct methods

tags-package-name.

Direct slots
Slot: name
Initargs

:name

Readers

tags-package-name.

Writers

This slot is read-only.

Condition: null-tests-warning
Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

simple-warning.

Direct methods

tests-package-name.

Direct slots
Slot: name
Initargs

:name

Readers

tests-package-name.

Writers

This slot is read-only.

Condition: test-name-error

The test name error is a type error.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

type-error.

Direct Default Initargs
InitargValue
:expected-type(quote symbol)

6.2.6 Classes

Class: boolean-result

Result of a failed boolean assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

failure-result.

Class: equal-result

Result of a failed equal assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

failure-result.

Class: error-result

Result of a failed error assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

failure-result.

Direct methods

print-failures.

Class: failure-result

Failure details of the assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: form
Initargs

:form

Readers

form.

Writers

This slot is read-only.

Slot: actual
Type

list

Initargs

:actual

Readers

actual.

Writers

This slot is read-only.

Slot: expected
Type

list

Initargs

:expected

Readers

expected.

Writers

This slot is read-only.

Slot: extras
Type

list

Initargs

:extras

Readers

extras.

Writers

This slot is read-only.

Slot: test
Type

function

Initargs

:test

Readers

test.

Writers

This slot is read-only.

Class: macro-result

Result of a failed macro expansion assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

failure-result.

Direct methods

print-failures.

Class: output-result

Result of a failed output assertion.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct superclasses

failure-result.

Direct methods

print-failures.

Class: test-result

Store the results of the unit test.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct methods
Direct Default Initargs
InitargValue
:exerrnil
Direct slots
Slot: name
Type

symbol

Initargs

:name

Readers

name.

Writers

This slot is read-only.

Slot: pass
Type

fixnum

Initargs

:pass

Readers

pass.

Writers

This slot is read-only.

Slot: fail
Type

list

Initargs

:fail

Readers

fail.

Writers

This slot is read-only.

Slot: exerr
Initargs

:exerr

Readers

exerr.

Writers

This slot is read-only.

Slot: run-time

Test run time measured in internal time units

Initargs

:run-time

Readers

run-time.

Writers

This slot is read-only.

Class: test-results-db

Store the results of the tests for further evaluation.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct methods
Direct slots
Slot: database
Type

hash-table

Initform

(make-hash-table :test (function eq))

Readers

database.

Writers

This slot is read-only.

Slot: pass
Type

fixnum

Initform

0

Readers

pass.

Writers

(setf pass).

Slot: fail
Type

fixnum

Initform

0

Readers

fail.

Writers

(setf fail).

Slot: exerr
Type

fixnum

Initform

0

Readers

exerr.

Writers

(setf exerr).

Slot: failed-tests
Type

list

Readers

failed-tests.

Writers

(setf failed-tests).

Slot: error-tests
Type

list

Readers

error-tests.

Writers

(setf error-tests).

Slot: missing-tests
Type

list

Readers

missing-tests.

Writers

(setf missing-tests).

Class: unit-test

Organize the unit test documentation and code.

Package

lisp-unit.

Source

lisp-unit.lisp.

Direct methods
Direct Default Initargs
InitargValue
:doc
:codenil
Direct slots
Slot: doc
Type

string

Initargs

:doc

Readers

doc.

Writers

This slot is read-only.

Slot: code
Type

list

Initargs

:code

Readers

code.

Writers

This slot is read-only.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %   (  
A   C   D   E   F   G   I   L   M   N   P   R   S   T   U   V   W  
Index Entry  Section

%
%array-error: Private ordinary functions
%array-indices: Private ordinary functions
%complex-float-random: Private ordinary functions
%complex-rational-random: Private ordinary functions
%expansion-equal: Private ordinary functions
%float-equal: Private ordinary functions
%norm: Private generic functions
%norm: Private generic functions
%norm: Private generic functions
%norm: Private generic functions
%norm: Private generic functions
%norm: Private generic functions
%norm: Private generic functions
%norm: Private generic functions
%norm: Private generic functions
%norm-equal: Private ordinary functions
%normalize-float: Private ordinary functions
%record-failure: Private ordinary functions
%relative-error: Private ordinary functions
%relative-error-norm: Private ordinary functions
%run-all-thunks: Private ordinary functions
%run-thunks: Private ordinary functions
%seq-float-equal: Private ordinary functions
%seq-rational-equal: Private ordinary functions
%seq-sigfig-equal: Private ordinary functions
%sequence-equal: Private ordinary functions
%sequence-error: Private ordinary functions
%sigfig-equal: Private ordinary functions
%tests-from-all-tags: Private ordinary functions
%tests-from-tags: Private ordinary functions
%write-tap-test-result: Private ordinary functions

(
(setf error-tests): Public generic functions
(setf error-tests): Public generic functions
(setf exerr): Private generic functions
(setf exerr): Private generic functions
(setf fail): Private generic functions
(setf fail): Private generic functions
(setf failed-tests): Public generic functions
(setf failed-tests): Public generic functions
(setf missing-tests): Public generic functions
(setf missing-tests): Public generic functions
(setf pass): Private generic functions
(setf pass): Private generic functions

A
actual: Private generic functions
actual: Private generic functions
array-error: Public ordinary functions
assert-eq: Public macros
assert-eql: Public macros
assert-equal: Public macros
assert-equality: Public macros
assert-equalp: Public macros
assert-error: Public macros
assert-expands: Public macros
assert-false: Public macros
assert-float-equal: Public macros
assert-nil: Public macros
assert-norm-equal: Public macros
assert-number-equal: Public macros
assert-numerical-equal: Public macros
assert-prints: Public macros
assert-rational-equal: Public macros
assert-result: Private generic functions
assert-result: Private generic functions
assert-result: Private generic functions
assert-result: Private generic functions
assert-result: Private generic functions
assert-result: Private generic functions
assert-sigfig-equal: Public macros
assert-true: Public macros

C
code: Private generic functions
code: Private generic functions
complex-random: Public ordinary functions

D
database: Private generic functions
database: Private generic functions
default-db-merge-function: Private ordinary functions
default-epsilon: Public generic functions
default-epsilon: Public generic functions
default-epsilon: Public generic functions
default-epsilon: Public generic functions
default-epsilon: Public generic functions
default-epsilon: Public generic functions
define-test: Public macros
doc: Private generic functions
doc: Private generic functions

E
error-tests: Public generic functions
error-tests: Public generic functions
exerr: Private generic functions
exerr: Private generic functions
exerr: Private generic functions
expand-assert: Private macros
expand-error-form: Private macros
expand-extras: Private macros
expand-macro-form: Private macros
expand-output-form: Private macros
expand-t-or-f: Private macros
expected: Private generic functions
expected: Private generic functions
extras: Private generic functions
extras: Private generic functions

F
fail: Private generic functions
fail: Private generic functions
fail: Private generic functions
failed-tests: Public generic functions
failed-tests: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
float-equal: Public generic functions
form: Private generic functions
form: Private generic functions
Function, %array-error: Private ordinary functions
Function, %array-indices: Private ordinary functions
Function, %complex-float-random: Private ordinary functions
Function, %complex-rational-random: Private ordinary functions
Function, %expansion-equal: Private ordinary functions
Function, %float-equal: Private ordinary functions
Function, %norm-equal: Private ordinary functions
Function, %normalize-float: Private ordinary functions
Function, %record-failure: Private ordinary functions
Function, %relative-error: Private ordinary functions
Function, %relative-error-norm: Private ordinary functions
Function, %run-all-thunks: Private ordinary functions
Function, %run-thunks: Private ordinary functions
Function, %seq-float-equal: Private ordinary functions
Function, %seq-rational-equal: Private ordinary functions
Function, %seq-sigfig-equal: Private ordinary functions
Function, %sequence-equal: Private ordinary functions
Function, %sequence-error: Private ordinary functions
Function, %sigfig-equal: Private ordinary functions
Function, %tests-from-all-tags: Private ordinary functions
Function, %tests-from-tags: Private ordinary functions
Function, %write-tap-test-result: Private ordinary functions
Function, array-error: Public ordinary functions
Function, complex-random: Public ordinary functions
Function, default-db-merge-function: Private ordinary functions
Function, internal-assert: Private ordinary functions
Function, list-tags: Public ordinary functions
Function, list-tests: Public ordinary functions
Function, logically-equal: Public ordinary functions
Function, make-2d-list: Public ordinary functions
Function, make-random-2d-array: Public ordinary functions
Function, make-random-2d-list: Public ordinary functions
Function, make-random-list: Public ordinary functions
Function, nappend-test-results-db: Private ordinary functions
Function, null-tags-warning-report: Private ordinary functions
Function, null-tests-warning-report: Private ordinary functions
Function, number-equal: Public ordinary functions
Function, package-table: Private ordinary functions
Function, package-tags: Private ordinary functions
Function, parse-body: Private ordinary functions
Function, print-summary: Private ordinary functions
Function, record-result: Private ordinary functions
Function, reduce-test-results-dbs: Public ordinary functions
Function, remove-tags: Public ordinary functions
Function, remove-tests: Public ordinary functions
Function, reset-counters: Private ordinary functions
Function, run-code: Private ordinary functions
Function, run-tags: Public ordinary functions
Function, run-test-thunk: Private ordinary functions
Function, run-tests: Public ordinary functions
Function, run-time-s: Private ordinary functions
Function, sequence-error: Private ordinary functions
Function, set-equal: Public ordinary functions
Function, signal-results: Public ordinary functions
Function, summarize-results: Public ordinary functions
Function, tagged-tests: Public ordinary functions
Function, test-code: Public ordinary functions
Function, test-documentation: Public ordinary functions
Function, test-name-error-report: Private ordinary functions
Function, test-names: Public ordinary functions
Function, test-package: Private ordinary functions
Function, use-debugger: Public ordinary functions
Function, use-debugger-p: Private ordinary functions
Function, valid-test-name: Private ordinary functions
Function, write-tap: Public ordinary functions
Function, write-tap-to-file: Public ordinary functions

G
Generic Function, %norm: Private generic functions
Generic Function, (setf error-tests): Public generic functions
Generic Function, (setf exerr): Private generic functions
Generic Function, (setf fail): Private generic functions
Generic Function, (setf failed-tests): Public generic functions
Generic Function, (setf missing-tests): Public generic functions
Generic Function, (setf pass): Private generic functions
Generic Function, actual: Private generic functions
Generic Function, assert-result: Private generic functions
Generic Function, code: Private generic functions
Generic Function, database: Private generic functions
Generic Function, default-epsilon: Public generic functions
Generic Function, doc: Private generic functions
Generic Function, error-tests: Public generic functions
Generic Function, exerr: Private generic functions
Generic Function, expected: Private generic functions
Generic Function, extras: Private generic functions
Generic Function, fail: Private generic functions
Generic Function, failed-tests: Public generic functions
Generic Function, float-equal: Public generic functions
Generic Function, form: Private generic functions
Generic Function, missing-tests: Public generic functions
Generic Function, name: Private generic functions
Generic Function, norm: Public generic functions
Generic Function, norm-equal: Public generic functions
Generic Function, numerical-equal: Public generic functions
Generic Function, pass: Private generic functions
Generic Function, print-errors: Public generic functions
Generic Function, print-failures: Public generic functions
Generic Function, rational-equal: Public generic functions
Generic Function, record-failure: Private generic functions
Generic Function, relative-error: Public generic functions
Generic Function, relative-error-norm: Public generic functions
Generic Function, results: Public generic functions
Generic Function, run-time: Private generic functions
Generic Function, sigfig-equal: Public generic functions
Generic Function, sump: Public generic functions
Generic Function, sumsq: Public generic functions
Generic Function, tags-package-name: Private generic functions
Generic Function, test: Private generic functions
Generic Function, tests-package-name: Private generic functions

I
internal-assert: Private ordinary functions

L
list-tags: Public ordinary functions
list-tests: Public ordinary functions
logically-equal: Public ordinary functions

M
Macro, assert-eq: Public macros
Macro, assert-eql: Public macros
Macro, assert-equal: Public macros
Macro, assert-equality: Public macros
Macro, assert-equalp: Public macros
Macro, assert-error: Public macros
Macro, assert-expands: Public macros
Macro, assert-false: Public macros
Macro, assert-float-equal: Public macros
Macro, assert-nil: Public macros
Macro, assert-norm-equal: Public macros
Macro, assert-number-equal: Public macros
Macro, assert-numerical-equal: Public macros
Macro, assert-prints: Public macros
Macro, assert-rational-equal: Public macros
Macro, assert-sigfig-equal: Public macros
Macro, assert-true: Public macros
Macro, define-test: Public macros
Macro, expand-assert: Private macros
Macro, expand-error-form: Private macros
Macro, expand-extras: Private macros
Macro, expand-macro-form: Private macros
Macro, expand-output-form: Private macros
Macro, expand-t-or-f: Private macros
Macro, with-package-table: Private macros
Macro, with-package-tags: Private macros
make-2d-list: Public ordinary functions
make-random-2d-array: Public ordinary functions
make-random-2d-list: Public ordinary functions
make-random-list: Public ordinary functions
Method, %norm: Private generic functions
Method, %norm: Private generic functions
Method, %norm: Private generic functions
Method, %norm: Private generic functions
Method, %norm: Private generic functions
Method, %norm: Private generic functions
Method, %norm: Private generic functions
Method, %norm: Private generic functions
Method, (setf error-tests): Public generic functions
Method, (setf exerr): Private generic functions
Method, (setf fail): Private generic functions
Method, (setf failed-tests): Public generic functions
Method, (setf missing-tests): Public generic functions
Method, (setf pass): Private generic functions
Method, actual: Private generic functions
Method, assert-result: Private generic functions
Method, assert-result: Private generic functions
Method, assert-result: Private generic functions
Method, assert-result: Private generic functions
Method, assert-result: Private generic functions
Method, code: Private generic functions
Method, database: Private generic functions
Method, default-epsilon: Public generic functions
Method, default-epsilon: Public generic functions
Method, default-epsilon: Public generic functions
Method, default-epsilon: Public generic functions
Method, default-epsilon: Public generic functions
Method, doc: Private generic functions
Method, error-tests: Public generic functions
Method, exerr: Private generic functions
Method, exerr: Private generic functions
Method, expected: Private generic functions
Method, extras: Private generic functions
Method, fail: Private generic functions
Method, fail: Private generic functions
Method, failed-tests: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, float-equal: Public generic functions
Method, form: Private generic functions
Method, missing-tests: Public generic functions
Method, name: Private generic functions
Method, norm: Public generic functions
Method, norm: Public generic functions
Method, norm: Public generic functions
Method, norm-equal: Public generic functions
Method, norm-equal: Public generic functions
Method, norm-equal: Public generic functions
Method, norm-equal: Public generic functions
Method, norm-equal: Public generic functions
Method, numerical-equal: Public generic functions
Method, numerical-equal: Public generic functions
Method, numerical-equal: Public generic functions
Method, numerical-equal: Public generic functions
Method, numerical-equal: Public generic functions
Method, numerical-equal: Public generic functions
Method, pass: Private generic functions
Method, pass: Private generic functions
Method, print-errors: Public generic functions
Method, print-errors: Public generic functions
Method, print-failures: Public generic functions
Method, print-failures: Public generic functions
Method, print-failures: Public generic functions
Method, print-failures: Public generic functions
Method, print-failures: Public generic functions
Method, print-failures: Public generic functions
Method, print-failures: Public generic functions
Method, print-object: Public standalone methods
Method, rational-equal: Public generic functions
Method, rational-equal: Public generic functions
Method, rational-equal: Public generic functions
Method, rational-equal: Public generic functions
Method, rational-equal: Public generic functions
Method, rational-equal: Public generic functions
Method, rational-equal: Public generic functions
Method, record-failure: Private generic functions
Method, record-failure: Private generic functions
Method, record-failure: Private generic functions
Method, record-failure: Private generic functions
Method, record-failure: Private generic functions
Method, relative-error: Public generic functions
Method, relative-error: Public generic functions
Method, relative-error: Public generic functions
Method, relative-error: Public generic functions
Method, relative-error-norm: Public generic functions
Method, relative-error-norm: Public generic functions
Method, relative-error-norm: Public generic functions
Method, relative-error-norm: Public generic functions
Method, relative-error-norm: Public generic functions
Method, results: Public generic functions
Method, run-time: Private generic functions
Method, sigfig-equal: Public generic functions
Method, sigfig-equal: Public generic functions
Method, sigfig-equal: Public generic functions
Method, sigfig-equal: Public generic functions
Method, sigfig-equal: Public generic functions
Method, sigfig-equal: Public generic functions
Method, sump: Public generic functions
Method, sump: Public generic functions
Method, sump: Public generic functions
Method, sumsq: Public generic functions
Method, sumsq: Public generic functions
Method, sumsq: Public generic functions
Method, tags-package-name: Private generic functions
Method, test: Private generic functions
Method, tests-package-name: Private generic functions
missing-tests: Public generic functions
missing-tests: Public generic functions

N
name: Private generic functions
name: Private generic functions
nappend-test-results-db: Private ordinary functions
norm: Public generic functions
norm: Public generic functions
norm: Public generic functions
norm: Public generic functions
norm-equal: Public generic functions
norm-equal: Public generic functions
norm-equal: Public generic functions
norm-equal: Public generic functions
norm-equal: Public generic functions
norm-equal: Public generic functions
null-tags-warning-report: Private ordinary functions
null-tests-warning-report: Private ordinary functions
number-equal: Public ordinary functions
numerical-equal: Public generic functions
numerical-equal: Public generic functions
numerical-equal: Public generic functions
numerical-equal: Public generic functions
numerical-equal: Public generic functions
numerical-equal: Public generic functions
numerical-equal: Public generic functions

P
package-table: Private ordinary functions
package-tags: Private ordinary functions
parse-body: Private ordinary functions
pass: Private generic functions
pass: Private generic functions
pass: Private generic functions
print-errors: Public generic functions
print-errors: Public generic functions
print-errors: Public generic functions
print-failures: Public generic functions
print-failures: Public generic functions
print-failures: Public generic functions
print-failures: Public generic functions
print-failures: Public generic functions
print-failures: Public generic functions
print-failures: Public generic functions
print-failures: Public generic functions
print-object: Public standalone methods
print-summary: Private ordinary functions

R
rational-equal: Public generic functions
rational-equal: Public generic functions
rational-equal: Public generic functions
rational-equal: Public generic functions
rational-equal: Public generic functions
rational-equal: Public generic functions
rational-equal: Public generic functions
rational-equal: Public generic functions
record-failure: Private generic functions
record-failure: Private generic functions
record-failure: Private generic functions
record-failure: Private generic functions
record-failure: Private generic functions
record-failure: Private generic functions
record-result: Private ordinary functions
reduce-test-results-dbs: Public ordinary functions
relative-error: Public generic functions
relative-error: Public generic functions
relative-error: Public generic functions
relative-error: Public generic functions
relative-error: Public generic functions
relative-error-norm: Public generic functions
relative-error-norm: Public generic functions
relative-error-norm: Public generic functions
relative-error-norm: Public generic functions
relative-error-norm: Public generic functions
relative-error-norm: Public generic functions
remove-tags: Public ordinary functions
remove-tests: Public ordinary functions
reset-counters: Private ordinary functions
results: Public generic functions
results: Public generic functions
run-code: Private ordinary functions
run-tags: Public ordinary functions
run-test-thunk: Private ordinary functions
run-tests: Public ordinary functions
run-time: Private generic functions
run-time: Private generic functions
run-time-s: Private ordinary functions

S
sequence-error: Private ordinary functions
set-equal: Public ordinary functions
sigfig-equal: Public generic functions
sigfig-equal: Public generic functions
sigfig-equal: Public generic functions
sigfig-equal: Public generic functions
sigfig-equal: Public generic functions
sigfig-equal: Public generic functions
sigfig-equal: Public generic functions
signal-results: Public ordinary functions
summarize-results: Public ordinary functions
sump: Public generic functions
sump: Public generic functions
sump: Public generic functions
sump: Public generic functions
sumsq: Public generic functions
sumsq: Public generic functions
sumsq: Public generic functions
sumsq: Public generic functions

T
tagged-tests: Public ordinary functions
tags-package-name: Private generic functions
tags-package-name: Private generic functions
test: Private generic functions
test: Private generic functions
test-code: Public ordinary functions
test-documentation: Public ordinary functions
test-name-error-report: Private ordinary functions
test-names: Public ordinary functions
test-package: Private ordinary functions
tests-package-name: Private generic functions
tests-package-name: Private generic functions

U
use-debugger: Public ordinary functions
use-debugger-p: Private ordinary functions

V
valid-test-name: Private ordinary functions

W
with-package-table: Private macros
with-package-tags: Private macros
write-tap: Public ordinary functions
write-tap-to-file: Public ordinary functions


A.3 Variables

Jump to:   *  
A   C   D   E   F   M   N   P   R   S   T  
Index Entry  Section

*
*epsilon*: Public special variables
*fail*: Private special variables
*measure*: Public special variables
*pass*: Private special variables
*print-errors*: Public special variables
*print-failures*: Public special variables
*print-summary*: Public special variables
*signal-results*: Private special variables
*significant-figures*: Public special variables
*summarize-results*: Public special variables
*tag-db*: Private special variables
*test-db*: Private special variables
*use-debugger*: Private special variables

A
actual: Private classes

C
code: Private classes

D
database: Private classes
doc: Private classes

E
error-tests: Private classes
exerr: Private classes
exerr: Private classes
expected: Private classes
extras: Private classes

F
fail: Private classes
fail: Private classes
failed-tests: Private classes
form: Private classes

M
missing-tests: Private classes

N
name: Private conditions
name: Private conditions
name: Private classes

P
pass: Private classes
pass: Private classes

R
results: Public conditions
run-time: Private classes

S
Slot, actual: Private classes
Slot, code: Private classes
Slot, database: Private classes
Slot, doc: Private classes
Slot, error-tests: Private classes
Slot, exerr: Private classes
Slot, exerr: Private classes
Slot, expected: Private classes
Slot, extras: Private classes
Slot, fail: Private classes
Slot, fail: Private classes
Slot, failed-tests: Private classes
Slot, form: Private classes
Slot, missing-tests: Private classes
Slot, name: Private conditions
Slot, name: Private conditions
Slot, name: Private classes
Slot, pass: Private classes
Slot, pass: Private classes
Slot, results: Public conditions
Slot, run-time: Private classes
Slot, test: Private classes
Special Variable, *epsilon*: Public special variables
Special Variable, *fail*: Private special variables
Special Variable, *measure*: Public special variables
Special Variable, *pass*: Private special variables
Special Variable, *print-errors*: Public special variables
Special Variable, *print-failures*: Public special variables
Special Variable, *print-summary*: Public special variables
Special Variable, *signal-results*: Private special variables
Special Variable, *significant-figures*: Public special variables
Special Variable, *summarize-results*: Public special variables
Special Variable, *tag-db*: Private special variables
Special Variable, *test-db*: Private special variables
Special Variable, *use-debugger*: Private special variables

T
test: Private classes


A.4 Data types

Jump to:   B   C   E   F   L   M   N   O   P   R   S   T   U  
Index Entry  Section

B
boolean-result: Private classes

C
Class, boolean-result: Private classes
Class, equal-result: Private classes
Class, error-result: Private classes
Class, failure-result: Private classes
Class, macro-result: Private classes
Class, output-result: Private classes
Class, test-result: Private classes
Class, test-results-db: Private classes
Class, unit-test: Private classes
Condition, null-tags-warning: Private conditions
Condition, null-tests-warning: Private conditions
Condition, test-name-error: Private conditions
Condition, test-run-complete: Public conditions

E
equal-result: Private classes
error-result: Private classes
extensions: The lisp-unit/extensions module

F
failure-result: Private classes
File, floating-point.lisp: The lisp-unit/extensions/floating-point․lisp file
File, lisp-unit.asd: The lisp-unit/lisp-unit․asd file
File, lisp-unit.lisp: The lisp-unit/lisp-unit․lisp file
File, rational.lisp: The lisp-unit/extensions/rational․lisp file
File, test-anything-protocol.lisp: The lisp-unit/extensions/test-anything-protocol․lisp file
floating-point.lisp: The lisp-unit/extensions/floating-point․lisp file

L
lisp-unit: The lisp-unit system
lisp-unit: The lisp-unit package
lisp-unit.asd: The lisp-unit/lisp-unit․asd file
lisp-unit.lisp: The lisp-unit/lisp-unit․lisp file

M
macro-result: Private classes
Module, extensions: The lisp-unit/extensions module

N
null-tags-warning: Private conditions
null-tests-warning: Private conditions

O
output-result: Private classes

P
Package, lisp-unit: The lisp-unit package

R
rational.lisp: The lisp-unit/extensions/rational․lisp file

S
System, lisp-unit: The lisp-unit system

T
test-anything-protocol.lisp: The lisp-unit/extensions/test-anything-protocol․lisp file
test-name-error: Private conditions
test-result: Private classes
test-results-db: Private classes
test-run-complete: Public conditions

U
unit-test: Private classes