The lisp-unit Reference Manual

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

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 Aug 15 05:13:44 2022 GMT+0.

Table of Contents


1 Introduction

lisp-unit

lisp-unit is a Common Lisp library that supports unit testing. It is an extension of the library written by Chris Riesbeck. There is a long history of testing packages in Lisp, usually called "regression" testers. More recent packages in Lisp and other languages have been inspired by JUnit for Java.

Documentation is located on the project wiki.

Features

Extensions

How to use lisp-unit

The core definitions of lisp-unit may be used by loading the single file 'lisp-unit.lisp'. To use the extensions, lisp-unit must be loaded using either Quicklisp or ASDF.

  1. Load (or compile and load) as a single file : (load "lisp-unit").
  2. Load using Quicklisp : (ql:quickload :lisp-unit).
  3. Load using ASDF : (asdf:load-system :lisp-unit).

Development Plan

Acknowledgments

Contributions to lisp-unit are noted in the wiki. Please let me know if any contributions have not been acknowledged.


2 Systems

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


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

2.1 lisp-unit

Common Lisp library that supports unit testing.

Author

Thomas M. Hermann <thomas.m.hermann@odonata-research.com>

License

MIT

Version

1.0.0

Source

lisp-unit.asd.

Child Components

3 Modules

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


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

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.


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

4.1 Lisp


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

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.


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

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.


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

6.1 Public Interface


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

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


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

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.


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

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.


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

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.


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

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)

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

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


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

A.1 Concepts


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

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

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

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

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

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

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

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

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