The lisp-unit2 Reference Manual

Table of Contents

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

The lisp-unit2 Reference Manual

This is the lisp-unit2 Reference Manual, version 0.2.0, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:12:00 2018 GMT+0.


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

1 Introduction

lisp-unit2

lisp-unit2 is a Common Lisp library that supports unit testing. It is a new version of a library of the lisp-unit 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.

Recently longtime users at Acceleration.net felt motivated to refactor significantly, attempting to make some broad improvements to the library while maintaining its benefits and workflow

Features

Differences from lisp-unit version 1

How to use lisp-unit2

  1. Load using Quicklisp : (ql:quickload :lisp-unit2) or ASDF : (asdf:load-system :lisp-unit2).
  2. Define some tests (for best luck define tests in their own package by making their name be in a specific package). By having tests in their own package, the test and the fn being tested can share the same name. (Tests are compiled to a function named after the test that runs it and an object in the test database)
(lisp-unit2:define-test my-tests::test-subtraction 
    (:tags '(my-tests::bar))
  (assert-eql 1 (- 2 1)))
  1. Run all tests in your package
;; with-summary provides results while the tests are running
;;;; using the context function
(run-tests :package :my-tests
           :run-contexts #'with-summary-context)

;;;; using the context macro (does the same thing as
;;;; :run-contexts, See Contexts below for an explanation).
(with-summary () (run-tests :package :my-tests))

;; to print the results after the run is complete
(print-summary (run-tests :tags 'my-tests::bar))

;; The difference is in whether or not the output occurs while the
;; tests are running or after all the tests have run

;; to disable the debugger:
(let (*debugger-hook*)
  (run-tests :tests 'my-tests::test-subtraction))

;; to debug failed assertions with the context function
(run-tests :tests 'my-tests::test-subtraction
           :run-contexts #'with-failure-debugging-context)

;; or use the context macro
(with-failure-debugging ()
  (run-tests :tests 'my-tests::test-subtraction))

See the internal test suite for more and better examples (internal-test/*)

Defining Tests

The define-test macro is the primary way to install a test. define-test creates a function with the same name as the test, which can be called to execute the test. This is nice because there is a direct way to call every test, but also because the test has implicit source destination and thus "go-to-definition" on any printing of the test name will take you directly to the test in question. define-test also creates a unit-test object and inserts it into the test-database.

The test body is compiled at the time of definition (so that any compile warnings or errors are immediately noticeable) and also before every run of the test (so that macro expansions are never out of date).

Undefining Tests

Because lisp-unit2 keeps a database of tests and functions, removing a tests is not as simple as deleteing the test from from your file. Instead a function uninstall-test and a macro undefine-test allow you to remove all the runtime components of a test from lisp-unit2. Uninstall-test accepts the test's symbolic name. Undefine-test is a macro whose form mimics define-test, so that you can simply add the two characters and compile the form to remove the test. This also gives you the ability to easily leave tests in your test file that are inactive currently.

Running Tests

The primary entry point for running tests is lisp-unit2:run-tests. run-tests and get-tests both accept (&key tests tags package reintern-package) as discussed below in "Test Organization". Each test can also be run individually by calling the function named for the test, and by calling lisp-unit2:run-test which each return a single test-result.

run-tests returns a test-results-db, and aside from the keys above accepts,

Once you have a test-result-db (or list there of) you can call rerun-tests or rerun-failures to rerun and produce new results.

Test Organization: Names, Tags, and Packages

Tests are organized by their name and by tags. Both of these are symbols in some package. Tests can be retrieved by their name, the package that their name is in, and any of the tags that reference the test.

The most common way to retrieve and run unit tests is run-tests which calls get-tests.

(lisp-unit2:run-tests &key tests tags package reintern-package) (lisp-unit2:get-tests &key tests tags package reintern-package)

Both of these functions accept:

If no arguments are provided lisp-unit2 will run all tests in package

In some cases, particularly when converting from lisp-unit(1) we need our tests to be in a different package (because tests are functions in their name's package). In lisp-unit these tests would not conflict with a function named the same (because tests were not functions). To ease conversion, the reintern-package argument will reintern all test names and tags provided into a different package. Define test accepts a package argument that mirrors this functionality. Suggested usage is to either have tests be named differently from the functions they test or to have tests and tags be in an explicitly referenced package, eg: (define-test my-tests::test1 (:tags '(my-tests::tag1)) ...)

Tests are organized into the *test-db* which is an instance test-database. These can be rebound if you needed to write tests about your test framework (see the internal example-tests).

Suites

While lisp-unit does not have any specific notion of a suite, it is believed that the tests are composable enough that explicit test suites are not needed.

One suggestion would be to have named functions that run you specific set of tests:

(defun run-{suite} ()
  (lisp-unit2:run-tests
    :name :{suite}
    {stuff to test} ))

(defun run-symbol-munger-and-lisp-unit2-tests () 
  (lisp-unit2:run-tests
    :name :symbol-munger-and-lisp-unit2-tests
    :package '(:symbol-munger-tests :lisp-unit2-tests)))

(defun run-error-and-basic-tests () 
  (lisp-unit2:run-tests
    :name :error-and-basic-tests
    :tests '(symbol-munger-test::test-basic)
    :tags '(:errors lisp-unit2-tests::errors)))

Another suggestion would be to define tests that call other tests:

(define-test suite-1 (:tags '(suites))
  (test-fn-1) ;; calls test-fn-1 unit-test
  (lisp-unit2::run-tests ...) ; runs an entire other set of unit tests)

Assertions

All assert-* macros signal assertion-pass and assertion-fail by comparing their expected results to the actual results during execution. All other values in the assert forms are assumed to be extra data to aid debugging.

assert-{equality-test} macros compare the actual to the expected value of each of the values returned from expected (see: multiple-values) (eg: (assert-eql exp act) => (eql act exp)) This ordering was used so that functions like typep, member, etc could be used as test.

assert-false and assert-true simply check the generic-boolean truth of their first arg (eg: null and (not null)

assert-{signal} and assert-{no-signal} macros are used for testing condition protocols. Signals that are expected/not-expected handled.

Multiple-values and assertions

Actual values are compared to all expected values, that is:

LISP-UNIT2-TESTS> (lisp-unit2:with-assertion-summary ()
                    (assert-eql (values 1 2) (values 1 2 3)))


<No Test>:Passed (ASSERT-EQL (VALUES 1 2) (VALUES 1 2 3))
T
LISP-UNIT2-TESTS> (lisp-unit2:with-assertion-summary ()
                    (assert-eql (values 1 2 3) (values 1 2)))

Failed Form: (ASSERT-EQL (VALUES 1 2 3) (VALUES 1 2))
Expected 1; 2; 3
but saw 1; 2

Debugging

Debugging is controlled by *debugger-hook* (as is usual in common-lisp). You can make lisp-unit simply record the error and move on by binding *debugger-hook* to nil around your run-tests call.

If you would like to debug failed assertions you can wrap your call in with-failure-debugging or apply the with-failure-debugging-context to the unit-test run.

Output and Results

All output is printed to *test-stream* (which by default is *standard-output*). Most forms do not output results by default, instead returning a result object. All results objects can be printed (to *test-stream*) by calling print-summary on the object in question.

print-summary prints information about passing as well as failing tests. print-failure-summary can be called to print only messages about failures, warnings, errors and empty tests (empty tests had no assertions). Care is taken to print tests with their short, but still fully packaged symbol-name (so that go-to-definition) works.

When running interactively with-summary(-context) can provide real-time output, printing start messages and result messages for each test. with-assertion-summary(-context) provides even more detailed output printing a message for each assertion passed or failed.

Test results (from one or many runs) can be captured using with-test-results. The arg: collection-place will copy all the results as they arrive into a location of your choosing (eg: variable, object slot). The arg: summarize? will print a failure summary of each test-run after all of the tests are finished running. This is useful for collecting separate results for many packages or systems (see test-asdf-system-recursive). If no args are provided summarize? is defaulted to true.

TAP Output

Lisp-unit2 provides TAP (test anything protocol) test results (printed in such a way that jenkins tap plugin can parse them).

with-tap-summary prints tap results as the tests run write-tap, write-tap-to-file accept a test-results database and write the TAP results either to test-stream or a file

ASDF

asdf:test-system is assumed to be the canonical way of testing a every system, and so lisp-unit2 makes effort to work well with test-system

Here is an example asdf:test-sytem definition, which will print the verbose summary of the tests as they run.

(defmethod asdf:perform ((o asdf:test-op) (c (eql (find-system :symbol-munger))))
  (asdf:oos 'asdf:load-op :symbol-munger-test)
  (let ((*package* (find-package :symbol-munger-test)))
    (eval (read-from-string "
            (lisp-unit2:with-summary ()
             (lisp-unit2:run-tests
              :package :symbol-munger-test
              :name :symbol-munger
              :run-context))
      "))))

Additionally, lisp-unit2 provides test-asdf-system-recursive which accepts a (list or single) system name, looks up all its dependencies and calls asdf:tests-system on each listed system. Any lisp-unit or lisp-unit2 test-results-dbs are collected and returned at the end. A failure summary is also printed for each result db (so that after running many tests you are presented with a short synopsis of what ran and what failed.

There is an interop layer for converting test results from other systems to lisp-unit2 test results, so that we can gather and summarize more information. Currently this is only implemented for lisp-unit1, but patches would be welcome to allow collecting test results from any other lisp test systems. (This is currently a bit tedious, simplification patches welcome as well, see interop.lisp).

Signals

Signals are used throughout lisp-unit2 to communicate progress and results throughout lisp unit

All signals have an abort interrupt which simply cancels the signal. This is mostly used for meta-testing (ie: testing lisp-unit2), but there are conceivably other uses.

Contexts / Fixtures

Contexts allow you to manipulate the dynamic state of a given unit-test or test-run. These are functions of a single required argument (a thunk), that they execute inside of a new/changed dynamic environment.

A good example is the with-failure-debugging-context, which simply invokes the debugger whenever we signal a failed assertion

(defun with-failure-debugging-context (body-fn)
  "A context that invokes the debugger on failed assertions"
  (handler-bind ((assertion-fail #'invoke-debugger))
    (funcall body-fn)))

Both define-test and run-tests accept a tree of contexts that is flattened and turned into a single context function (see combine-contexts). This function then executes the body-fn for us (see: do-contexts).

This should allow any type of manipulation of the current lisp-unit2 environment through access to handling signals and setting up and tearing down dynamic environments.

Example Contexts:

Example test-with-contexts defintion:

(defmacro db-render-test (name (&rest args) &body body)
  `(lisp-unit2:define-test ,name
    (:tags ',args
     :contexts
     (list #'test-context #'dom-context #'database-context )
     :package :test-objects)
    ,@body))

Data Model

Remaining Tasks

Future Features

0.2.0 Acknowledgments

0.9.5 Acknowledgments


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

2 Systems

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


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

2.1 lisp-unit2

Author

Russ Tyndall <russ@acceleration.net>

License

MIT

Description

Common Lisp library that supports unit testing.

Version

0.2.0

Dependencies
Source

lisp-unit2.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 lisp-unit2.asd

Location

lisp-unit2.asd

Systems

lisp-unit2 (system)


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

3.1.2 lisp-unit2/package.lisp

Parent

lisp-unit2 (system)

Location

package.lisp

Packages

lisp-unit2


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

3.1.3 lisp-unit2/assert-package.lisp

Dependency

package.lisp (file)

Parent

lisp-unit2 (system)

Location

assert-package.lisp

Packages

lisp-unit2-asserts


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

3.1.4 lisp-unit2/vars.lisp

Dependency

assert-package.lisp (file)

Parent

lisp-unit2 (system)

Location

vars.lisp

Exported Definitions
Internal Definitions

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

3.1.5 lisp-unit2/collectors.lisp

Dependency

vars.lisp (file)

Parent

lisp-unit2 (system)

Location

collectors.lisp

Internal Definitions

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

3.1.6 lisp-unit2/asserts.lisp

Dependency

collectors.lisp (file)

Parent

lisp-unit2 (system)

Location

asserts.lisp

Exported Definitions
Internal Definitions

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

3.1.7 lisp-unit2/lisp-unit.lisp

Dependency

asserts.lisp (file)

Parent

lisp-unit2 (system)

Location

lisp-unit.lisp

Exported Definitions
Internal Definitions

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

3.1.8 lisp-unit2/summarize.lisp

Dependency

lisp-unit.lisp (file)

Parent

lisp-unit2 (system)

Location

summarize.lisp

Exported Definitions
Internal Definitions

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

3.1.9 lisp-unit2/rational.lisp

Dependency

summarize.lisp (file)

Parent

lisp-unit2 (system)

Location

rational.lisp

Exported Definitions
Internal Definitions

%seq-rational-equal (function)


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

3.1.10 lisp-unit2/floating-point.lisp

Dependency

rational.lisp (file)

Parent

lisp-unit2 (system)

Location

floating-point.lisp

Exported Definitions
Internal Definitions

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

3.1.11 lisp-unit2/test-anything-protocol.lisp

Dependency

floating-point.lisp (file)

Parent

lisp-unit2 (system)

Location

test-anything-protocol.lisp

Exported Definitions
Internal Definitions

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

3.1.12 lisp-unit2/interop.lisp

Dependency

test-anything-protocol.lisp (file)

Parent

lisp-unit2 (system)

Location

interop.lisp

Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 lisp-unit2

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

4.2 lisp-unit2-asserts

Source

assert-package.lisp (file)


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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *epsilon*

Set the error epsilon if the defaults are not acceptable.

Package

lisp-unit2

Source

floating-point.lisp (file)

Special Variable: *measure*
Package

lisp-unit2

Source

floating-point.lisp (file)

Special Variable: *result*

The current test result (bound in %run-test)

Package

lisp-unit2

Source

vars.lisp (file)

Special Variable: *results*

The current results database (bound in run-tests)

Package

lisp-unit2

Source

vars.lisp (file)

Special Variable: *significant-figures*

Default to 4 significant figures.

Package

lisp-unit2

Source

floating-point.lisp (file)

Special Variable: *test-db*

The unit test database is a list of tests and some hashtable indexes

Package

lisp-unit2

Source

vars.lisp (file)

Special Variable: *test-stream*
Package

lisp-unit2

Source

vars.lisp (file)

Special Variable: *unit-test*

The currently executing unit test (bound in %run-test, ie every test function)

Package

lisp-unit2

Source

vars.lisp (file)


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

5.1.2 Macros

Macro: assert-eq EXPECTED FORM &rest EXTRAS

Assert whether expected and form are EQ.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-eql EXPECTED FORM &rest EXTRAS

Assert whether expected and form are EQL.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-equal EXPECTED FORM &rest EXTRAS

Assert whether expected and form are EQUAL.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-equality TEST EXPECTED FORM &rest EXTRAS

Assert whether expected and form are equal according to test.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-equalp EXPECTED FORM &rest EXTRAS

Assert whether expected and form are EQUALP.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-error CONDITION FORM &rest EXTRAS

Assert whether form signals condition.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-expands EXPANSION FORM &rest EXTRAS

Assert whether form expands to expansion.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-false FORM &rest EXTRAS

Assert whether the form is false.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-float-equal EXPECTED FORM &rest EXTRAS
Package

lisp-unit2

Source

floating-point.lisp (file)

Macro: assert-no-error CONDITION FORM &rest EXTRAS

Assert whether form signals condition.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-no-signal CONDITION FORM &rest EXTRAS
Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-no-warning CONDITION FORM &rest EXTRAS
Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-norm-equal EXPECTED FORM &rest EXTRAS
Package

lisp-unit2

Source

floating-point.lisp (file)

Macro: assert-number-equal EXPECTED FORM &rest EXTRAS
Package

lisp-unit2

Source

floating-point.lisp (file)

Macro: assert-numerical-equal EXPECTED FORM &rest EXTRAS
Package

lisp-unit2

Source

floating-point.lisp (file)

Macro: assert-prints OUTPUT FORM &rest EXTRAS

Assert whether printing the form generates the output.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-rational-equal EXPECTED FORM &rest EXTRAS
Package

lisp-unit2

Source

rational.lisp (file)

Macro: assert-sigfig-equal EXPECTED FORM &rest EXTRAS
Package

lisp-unit2

Source

floating-point.lisp (file)

Macro: assert-signal CONDITION FORM &rest EXTRAS
Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-true FORM &rest EXTRAS

Assert whether the form is true.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-typep EXPECTED-TYPE FORM &rest EXTRAS

Assert whether expected and form are TYPEP.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: assert-warning CONDITION FORM &rest EXTRAS
Package

lisp-unit2

Source

asserts.lisp (file)

Macro: define-test NAME (&key TAGS CONTEXTS PACKAGE) &body BODY

Defines a new test object, test functions and installs the test
function in the test database

name: the name of the test and the test-function

contexts: a (lambda (fn)...) (or list of) that runs the fn in a dynamic context

tags: symbols that can be used to group tests

If package is provided, the name and any provided tags are reinterned into package before use. Keywords are left alone. This is useful because many times tests and the functions they test, coexist (and always could in lisp-unit v1, now that we create test functions, we dont want them overwriting the original function).

Note: This should probably not be used (rather opting for packaged::symbols), but will be useful when converting from lisp-unit 1->2. See also: run-tests, get-tests reintern-package

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Macro: undefine-test NAME (&key TAGS CONTEXTS PACKAGE) &body BODY
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Macro: with-assertion-summary () &body BODY
Package

lisp-unit2

Source

summarize.lisp (file)

Macro: with-failure-debugging () &body BODY

A context macro that invokes the debugger on failed assertions

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: with-summary (&key NAME) &body BODY
Package

lisp-unit2

Source

summarize.lisp (file)

Macro: with-tap-summary () &body BODY
Package

lisp-unit2

Source

test-anything-protocol.lisp (file)

Macro: with-test-results (&key COLLECTION-PLACE SUMMARIZE?) &body BODY

see with-test-results-context

Package

lisp-unit2

Source

summarize.lisp (file)

Macro: with-test-signals-muffled () &body BODY
Package

lisp-unit2

Source

lisp-unit.lisp (file)


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

5.1.3 Functions

Function: array-error ARRAY1 ARRAY2 &key TEST ERROR-FUNCTION

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

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: complex-random LIMIT &optional STATE

Return a random complex number.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: get-tests &key TESTS TAGS PACKAGE REINTERN-PACKAGE EXCLUDE-TESTS EXCLUDE-TAGS &aux DB OUT

finds tests by names, tags, and package

if reintern-package is provided, reintern all symbols provided for tests and tags into the reintern-package. Mostly provided for easing conversion of lisp-unit1 test suites

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: list-tags ()

Return a list of the tags

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: list-tests ()

Return a list of all tests,
use get tests to find tests by package tag or name

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: logically-equal X Y
Package

lisp-unit2

Source

asserts.lisp (file)

Function: make-2d-list ROWS COLUMNS &key INITIAL-ELEMENT

Return a nested list with INITIAL-ELEMENT.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: make-random-2d-array ROWS COLUMNS &optional LIMIT

Return a 2D array of random numbers.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: make-random-2d-list ROWS COLUMNS &optional LIMIT

Return a nested list of random numbers.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: make-random-list SIZE &optional LIMIT

Return a list of random numbers.

Package

lisp-unit2

Source

floating-point.lisp (file)

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

Source

floating-point.lisp (file)

Function: print-failure-summary O &aux *PRINT-PRETTY*
Package

lisp-unit2

Source

summarize.lisp (file)

Function: print-summary O &aux *PRINT-PRETTY*
Package

lisp-unit2

Source

summarize.lisp (file)

Function: remove-tags &optional TAGS

Remove individual tags or entire sets.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: remove-tests &optional TESTS TAGS PACKAGE

Remove individual tests or entire sets.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: reset-test-database ()
Package

lisp-unit2

Source

lisp-unit.lisp (file)

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

Source

asserts.lisp (file)

Function: test-code NAME

Returns the code stored for the test name.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: test-documentation NAME

Return the documentation for the test.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: with-assertion-summary-context BODY-FN &aux *PRINT-PRETTY* RTN
Package

lisp-unit2

Source

summarize.lisp (file)

Function: with-failure-debugging-context BODY-FN

A context that invokes the debugger on failed assertions

Package

lisp-unit2

Source

asserts.lisp (file)

Function: with-summary-context BODY-FN &key NAME &aux *PRINT-PRETTY* RTN
Package

lisp-unit2

Source

summarize.lisp (file)

Function: with-tap-context BODY-FN
Package

lisp-unit2

Source

test-anything-protocol.lisp (file)

Function: with-test-results-context BODY-FN &key COLLECTION-PLACE-SETTER SUMMARIZE? &aux RTN TEST-RESULT-DBS

A context that collects test-result-databases
if collection-place-setter (lambda (new) (setf collection-place new)) exists anytime we get a new test result we set the place to the new collection

if summarize? at the end of the block we print the results summary for all tests this defaults to T if no collection-place-setter is provided and nil otherwise

Package

lisp-unit2

Source

summarize.lisp (file)

Function: write-tap TEST-RESULTS

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

Package

lisp-unit2

Source

test-anything-protocol.lisp (file)

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

Source

test-anything-protocol.lisp (file)


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

5.1.4 Generic functions

Generic Function: default-epsilon VALUE

Return the default epsilon for the value.

Package

lisp-unit2

Source

floating-point.lisp (file)

Methods
Method: default-epsilon VALUE
Generic Function: empty OBJECT
Generic Function: (setf empty) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: empty (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf empty) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

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

lisp-unit2

Methods
Method: errors (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf errors) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

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

lisp-unit2

Methods
Method: failed (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf failed) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: float-equal DATA1 DATA2 &optional EPSILON

Return true if the floating point data is equal.

Package

lisp-unit2

Source

floating-point.lisp (file)

Methods
Method: float-equal X Y &optional EPSILON
Generic Function: missing OBJECT
Generic Function: (setf missing) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: missing (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf missing) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: norm DATA &optional MEASURE

Return the element-wise norm of the data.

Package

lisp-unit2

Source

floating-point.lisp (file)

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

Source

floating-point.lisp (file)

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

Source

floating-point.lisp (file)

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: passed OBJECT
Generic Function: (setf passed) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: passed (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf passed) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: print-status-summary OBJECT STATUS
Package

lisp-unit2

Source

summarize.lisp (file)

Methods
Method: print-status-summary (DB test-results-db) (STATUS list)
Method: print-status-summary (DB test-results-db) (S symbol) &aux OBJS
Method: print-status-summary (O test-result) (S symbol) &aux OBJS
Generic Function: rational-equal DATA1 DATA2

Return true if the rational data is equal.

Package

lisp-unit2

Source

rational.lisp (file)

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

Source

floating-point.lisp (file)

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

Source

floating-point.lisp (file)

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 Function: rerun-failures TEST-RESULTS-DB &key STATUS

reruns failed tests

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: rerun-failures (DBS list) &key STATUS
Method: rerun-failures (DB test-results-db) &key STATUS
Generic Function: rerun-tests TEST-RESULTS-DB

Rerun all tests from a given run (returns new results)

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: rerun-tests (DBS list)
Method: rerun-tests (DB test-results-db)
Generic Function: results CONDITION
Generic Function: (setf results) NEW-VALUE CONDITION
Package

lisp-unit2

Methods
Method: results (TEST-RESULTS-DB test-results-db)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf results) NEW-VALUE (TEST-RESULTS-DB test-results-db)

automatically generated writer method

Source

lisp-unit.lisp (file)

Method: results (CONDITION collect-test-results)
Method: (setf results) NEW-VALUE (CONDITION collect-test-results)
Source

vars.lisp (file)

Method: results (CONDITION all-tests-complete)
Method: (setf results) NEW-VALUE (CONDITION all-tests-complete)
Source

vars.lisp (file)

Method: results (CONDITION all-tests-start)
Method: (setf results) NEW-VALUE (CONDITION all-tests-start)
Source

vars.lisp (file)

Generic Function: run-test TEST &key TEST-CONTEXTS
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: run-test (N symbol) &key TEST-CONTEXTS
Method: run-test (U symbol) &key TEST-CONTEXTS around
Method: run-test (U unit-test) &key TEST-CONTEXTS
Generic Function: run-tests &key TESTS TAGS PACKAGE NAME EXCLUDE-TESTS EXCLUDE-TAGS TEST-CONTEXTS RUN-CONTEXTS REINTERN-PACKAGE

Run the specified tests.

We run all the listed tests, and all tests tagged with tags. If both test
and tags are nil (the default), then we run all tests in
package (defaulting to *package*)

name is the name of the test run. Generally expected to be the name of the system being tested. Can be defaulted with the name parameter of with-summary as well. can also be defaulted with.

reintern-package: when looking up tests, first reintern all tests and tags
in this package. In general this should probably not be used, but is provided for convenience in transitioning from lisp-unit 1 to 2 (see: define-test package)

test-contexts is a list of contexts that will be applied around
each individual test

run-contexts is a list of contexts that will be applied around the entire
suite (around signals)

exclude-tests, exclude-tags: tests / tags to remove from the
run. explicit inclusion overrides, explicit exclusion, overrides
implicit inclusion
EG: (define-test test-takes-forever (manual stuff) ...)
(find-test :tags ’stuff :exclude-tags ’manual)
will not find test-takes-forever
(find-test :tags ’(stuff manual) :exclude-tags ’manual)
(find-test :tests ’test-takes-forever :exclude-tags ’manual)
both will find test-takes-forever

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: run-tests &key TESTS TAGS PACKAGE NAME EXCLUDE-TESTS EXCLUDE-TAGS TEST-CONTEXTS RUN-CONTEXTS REINTERN-PACKAGE around
Method: run-tests &rest ARGS &key TESTS TAGS PACKAGE REINTERN-PACKAGE NAME EXCLUDE-TESTS EXCLUDE-TAGS TEST-CONTEXTS RUN-CONTEXTS &aux ALL-TESTS RESULTS *RESULTS*
Generic Function: sigfig-equal DATA1 DATA2 &optional SIGNIFICANT-FIGURES

Return true if the data have equal significant figures.

Package

lisp-unit2

Source

floating-point.lisp (file)

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

Source

floating-point.lisp (file)

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

Source

floating-point.lisp (file)

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.

Generic Function: uninstall-test TEST

Uninstalls a previously defined unit test

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: uninstall-test (N symbol)
Method: uninstall-test (U unit-test) &aux N
Generic Function: unit-test CONDITION
Generic Function: (setf unit-test) NEW-VALUE CONDITION
Package

lisp-unit2

Methods
Method: unit-test (TEST-RESULT test-result)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf unit-test) NEW-VALUE (TEST-RESULT test-result)

automatically generated writer method

Source

lisp-unit.lisp (file)

Method: unit-test (FAILURE-RESULT failure-result)

automatically generated reader method

Source

asserts.lisp (file)

Method: (setf unit-test) NEW-VALUE (FAILURE-RESULT failure-result)

automatically generated writer method

Source

asserts.lisp (file)

Method: unit-test (CONDITION assertion-fail)
Method: (setf unit-test) NEW-VALUE (CONDITION assertion-fail)
Source

asserts.lisp (file)

Method: unit-test (CONDITION assertion-pass)
Method: (setf unit-test) NEW-VALUE (CONDITION assertion-pass)
Source

asserts.lisp (file)

Method: unit-test (CONDITION test-start)
Method: (setf unit-test) NEW-VALUE (CONDITION test-start)
Source

vars.lisp (file)

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

lisp-unit2

Methods
Method: warnings (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf warnings) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)


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

5.1.5 Conditions

Condition: all-tests-complete ()

Signaled when a test run is finished.

Package

lisp-unit2

Source

vars.lisp (file)

Direct superclasses

condition (condition)

Direct methods
  • name (method)
  • name (method)
  • results (method)
  • results (method)
Direct slots
Slot: results
Initargs

:results

Initform

(quote nil)

Readers

results (generic function)

Writers

(setf results) (generic function)

Slot: name

Name for this test results

Initargs

:name

Initform

(quote nil)

Readers

name (generic function)

Writers

(setf name) (generic function)

Condition: all-tests-start ()

Signaled when a single test starts.

Package

lisp-unit2

Source

vars.lisp (file)

Direct superclasses

condition (condition)

Direct methods
  • results (method)
  • results (method)
Direct slots
Slot: results
Initargs

:results

Initform

(quote nil)

Readers

results (generic function)

Writers

(setf results) (generic function)

Condition: assertion-fail ()
Package

lisp-unit2

Source

asserts.lisp (file)

Direct superclasses

condition (condition)

Direct methods
Direct slots
Slot: unit-test
Initargs

:unit-test

Initform

(quote lisp-unit2:*unit-test*)

Readers

unit-test (generic function)

Writers

(setf unit-test) (generic function)

Slot: assertion
Initargs

:assertion

Initform

(quote nil)

Readers

assertion (generic function)

Writers

(setf assertion) (generic function)

Slot: failure
Initargs

:failure

Initform

(quote nil)

Readers

failure (generic function)

Writers

(setf failure) (generic function)

Condition: assertion-pass ()
Package

lisp-unit2

Source

asserts.lisp (file)

Direct superclasses

condition (condition)

Direct methods
Direct slots
Slot: unit-test
Initargs

:unit-test

Initform

(quote lisp-unit2:*unit-test*)

Readers

unit-test (generic function)

Writers

(setf unit-test) (generic function)

Slot: assertion
Initargs

:assertion

Initform

(quote nil)

Readers

assertion (generic function)

Writers

(setf assertion) (generic function)

Condition: collect-test-results ()

Signaled that with-test-results should collect this test-result-database

Package

lisp-unit2

Source

vars.lisp (file)

Direct superclasses

condition (condition)

Direct methods
  • results (method)
  • results (method)
Direct slots
Slot: results
Initargs

:results

Initform

(quote nil)

Readers

results (generic function)

Writers

(setf results) (generic function)

Condition: missing-test ()

Signaled when a single test is finished.

Package

lisp-unit2

Source

vars.lisp (file)

Direct superclasses

warning (condition)

Direct methods
Direct slots
Slot: test-name
Initargs

:test-name

Initform

(quote nil)

Readers

test-name (generic function)

Writers

(setf test-name) (generic function)

Condition: test-complete ()

Signaled when a single test is finished.

Package

lisp-unit2

Source

vars.lisp (file)

Direct superclasses

condition (condition)

Direct methods
  • result (method)
  • result (method)
Direct slots
Slot: result
Initargs

:result

Initform

(quote nil)

Readers

result (generic function)

Writers

(setf result) (generic function)

Condition: test-start ()

Signaled when a single test starts.

Package

lisp-unit2

Source

vars.lisp (file)

Direct superclasses

condition (condition)

Direct methods
Direct slots
Slot: unit-test
Initargs

:unit-test

Initform

(quote nil)

Readers

unit-test (generic function)

Writers

(setf unit-test) (generic function)


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

5.1.6 Classes

Class: failure-result ()

Failure details of the assertion.

Package

lisp-unit2

Source

asserts.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: unit-test
Initargs

:unit-test

Initform

lisp-unit2:*unit-test*

Readers

unit-test (generic function)

Writers

(setf unit-test) (generic function)

Slot: form
Initargs

:form

Readers

form (generic function)

Writers

(setf form) (generic function)

Slot: actual
Initargs

:actual

Readers

actual (generic function)

Writers

(setf actual) (generic function)

Slot: expected
Initargs

:expected

Readers

expected (generic function)

Writers

(setf expected) (generic function)

Slot: extras
Initargs

:extras

Readers

extras (generic function)

Writers

(setf extras) (generic function)

Slot: test
Initargs

:test

Readers

test (generic function)

Writers

(setf test) (generic function)

Class: test-result ()
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses

test-results-mixin (class)

Direct methods
Direct slots
Slot: unit-test
Initargs

:unit-test

Initform

lisp-unit2:*unit-test*

Readers

unit-test (generic function)

Writers

(setf unit-test) (generic function)

Slot: return-value
Initargs

:return-value

Readers

return-value (generic function)

Writers

(setf return-value) (generic function)

Class: test-results-db ()

Store the results of the tests for further evaluation.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Slot: tests
Initargs

:tests

Readers

tests (generic function)

Writers

(setf tests) (generic function)

Slot: results
Initargs

:results

Readers

results (generic function)

Writers

(setf results) (generic function)

Slot: args
Initargs

:args

Readers

args (generic function)

Writers

(setf args) (generic function)

Class: unit-test ()

Organize the unit test documentation and code.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses

unit-test-control-mixin (class)

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Writers

(setf name) (generic function)

Slot: doc
Initargs

:doc

Readers

doc (generic function)

Writers

(setf doc) (generic function)

Slot: code

The forms to produce the fn

Initargs

:code

Readers

code (generic function)

Writers

(setf code) (generic function)

Slot: tags
Initargs

:tags

Readers

tags (generic function)

Writers

(setf tags) (generic function)

Slot: most-recent-result
Initargs

:most-recent-result

Readers

most-recent-result (generic function)

Writers

(setf most-recent-result) (generic function)

Slot: eval-package
Initargs

:eval-package

Readers

eval-package (generic function)

Writers

(setf eval-package) (generic function)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *log-level*
Package

lisp-unit2

Source

vars.lisp (file)

Special Variable: *test-log-stream*
Package

lisp-unit2

Source

vars.lisp (file)

Special Variable: +interop-test-result-contexts+
Package

lisp-unit2

Source

interop.lisp (file)

Special Variable: +statuses+

List of statuses in order of priority for categorizing test runs

Package

lisp-unit2

Source

vars.lisp (file)


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

5.2.2 Macros

Macro: %collect! IT PLACE
Package

lisp-unit2

Source

collectors.lisp (file)

Macro: %collect-new! IT PLACE &key TEST KEY
Package

lisp-unit2

Source

collectors.lisp (file)

Macro: %decollect! IT PLACE &key TEST KEY
Package

lisp-unit2

Source

collectors.lisp (file)

Macro: %log MESSAGE &key LEVEL
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Macro: %log-around (MESSAGE &key START-LEVEL END-LEVEL) &body BODY
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Macro: expand-assert TYPE FORM BODY EXPECTED EXTRAS &key TEST FULL-FORM

Expand the assertion to the internal format.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: expand-extras EXTRAS

Expand extra forms.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: expand-macro-form FORM &optional ENV

Expand the macro form once.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: expand-output-form FORM

Capture the output of the form in a string.

Package

lisp-unit2

Source

asserts.lisp (file)

Macro: pprint-test-block (&key PER-LINE-PREFIX) &body BODY
Package

lisp-unit2

Source

summarize.lisp (file)


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

5.2.3 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-unit2

Source

floating-point.lisp (file)

Function: %array-indices ROW-MAJOR-INDEX DIMENSIONS

Recursively calculate the indices from the row major index.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %complex-float-random LIMIT &optional STATE

Return a random complex float number.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %complex-rational-random LIMIT &optional STATE

Return a random complex rational number.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %dequote IT
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: %form-equal FORM1 FORM2 &aux INVALID

Descend into the forms checking for equality.

The first unequal part is the second value

Package

lisp-unit2

Source

asserts.lisp (file)

Function: %has? STATUS THING &aux N
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: %in-package N &optional PACKAGE &aux *PACKAGE*
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: %norm-equal SEQ1 SEQ2 EPSILON MEASURE

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

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %normalize-float SIGNIFICAND &optional EXPONENT

Return the normalized floating point number and exponent.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %out S &rest ARGS &aux *PRINT-PRETTY*
Package

lisp-unit2

Source

summarize.lisp (file)

Function: %relative-error EXACT APPROXIMATE

Return the relative error of the numbers.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %relative-error-norm EXACT APPROXIMATE MEASURE

Return the relative error norm of the sequences.

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %run-test U &key TEST-CONTEXTS &aux RESULT *UNIT-TEST* *RESULT*

This should only be called from run-test-name, which everyone else should call This ensures our test name is easily in the inspector and the redefining a test then retrying calls the new test body

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: %run-test-name U &key TEST-CONTEXTS
Package

lisp-unit2

Source

lisp-unit.lisp (file)

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

Source

rational.lisp (file)

Function: %seq-sigfig-equal SEQ1 SEQ2 SIGNIFICANT-FIGURES

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

Package

lisp-unit2

Source

floating-point.lisp (file)

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

Source

floating-point.lisp (file)

Function: %sequence-error SEQUENCE1 SEQUENCE2 TEST ERROR-FUNCTION

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

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %sigfig-equal FLOAT1 FLOAT2 SIGNIFICANT-FIGURES

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

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: %to-test ID

Coerces its argument to a unit-test argument

always look up by name so that rerunning a suite after uninstalling a test behaves appropriately

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: %ts &optional TIME

returns a date as {y}{mon}{d}-{h}{min}{s}, defaults to get-universal-time intended for use in datestamping filenames

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: %uninstall-name N &optional TAGS &aux DB PACKAGE
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: %write-tap-test-result TEST-RESULT I

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

Package

lisp-unit2

Source

test-anything-protocol.lisp (file)

Function: combine-contexts &rest CONTEXTS

Takes a list of nils and contexts and combines them into a single context (or null of no contexts were provided)

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: do-contexts BODY-FN &rest CONTEXTS

runs the body-fn inside of contexts, the last context will be the outermost all nils in contexts are ignored

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: expand-signaled-handler WHOLE CONDITION FORM EXTRAS SHOULD-BE-SIGNALED?
Package

lisp-unit2

Source

asserts.lisp (file)

Function: get-system-list START &aux LIST
Package

lisp-unit2

Source

interop.lisp (file)

Function: internal-assert TYPE FORM CODE-THUNK EXPECTED-THUNK EXTRAS TEST &key FULL-FORM

Perform the assertion and record the results.

Package

lisp-unit2

Source

asserts.lisp (file)

Function: null-tags-warning-report NULL-TAGS-WARNING STREAM

Write the null-tags-warning to the stream.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: null-tests-warning-report NULL-TESTS-WARNING STREAM

Write the null-tests-warning to the stream.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: print-tap TEST-RESULTS

Alias for write-tap for backwards and forwards consistency

Package

lisp-unit2

Source

test-anything-protocol.lisp (file)

Function: record-result-context BODY

as we are finishing a test (ie: it has the right status) record the result

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: sequence-error SEQUENCE1 SEQUENCE2 &key TEST ERROR-FUNCTION

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

Package

lisp-unit2

Source

floating-point.lisp (file)

Function: short-full-name S
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: status U
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: test-name-error-report TEST-NAME-ERROR STREAM

Write the test-name-error to the stream.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: test-signals-muffled-context BODY-FN
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Function: valid-test-name NAME

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

Package

lisp-unit2

Source

lisp-unit.lisp (file)


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

5.2.4 Generic functions

Generic Function: %collect IT OBJECT
Package

lisp-unit2

Source

collectors.lisp (file)

Methods
Method: %collect IT (O null)
Method: %collect IT (O list-collector) &aux C
Generic Function: %collect-new IT OBJECT &key TEST KEY
Package

lisp-unit2

Source

collectors.lisp (file)

Methods
Method: %collect-new IT (O null) &key TEST KEY
Method: %collect-new IT (O list-collector) &key TEST KEY
Generic Function: %compile UNIT-TEST
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: %compile (U unit-test)
Generic Function: %decollect IT OBJECT &key TEST KEY
Package

lisp-unit2

Source

collectors.lisp (file)

Methods
Method: %decollect IT (O null) &key TEST KEY
Method: %decollect IT (O list-collector) &key TEST KEY
Generic Function: %norm DATA MEASURE

Return the norm of the data according to measure.

Package

lisp-unit2

Source

floating-point.lisp (file)

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 Function: %print-result-summary DB
Package

lisp-unit2

Source

summarize.lisp (file)

Methods
Method: %print-result-summary (O test-results-db)
Generic Function: %print-summary O

Print a summary of all results to the stream.

Package

lisp-unit2

Source

summarize.lisp (file)

Methods
Method: %print-summary (O vector)
Method: %print-summary (O list)
Method: %print-summary (O test-results-db)
Method: %print-summary (RUN test-result)
Method: %print-summary (RESULT failure-result) around
Method: %print-summary (RESULT failure-result)
Method: %print-summary (RESULT error-result)
Method: %print-summary (RESULT macro-result)
Method: %print-summary (RESULT output-result)
Method: %print-summary (W warning)
Method: %print-summary (E error)
Method: %print-summary IT
Generic Function: %tests OBJECT
Generic Function: (setf %tests) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: %tests (TEST-DATABASE test-database)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf %tests) NEW-VALUE (TEST-DATABASE test-database)

automatically generated writer method

Source

lisp-unit.lisp (file)

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

lisp-unit2

Methods
Method: actual (FAILURE-RESULT failure-result)

automatically generated reader method

Source

asserts.lisp (file)

Method: (setf actual) NEW-VALUE (FAILURE-RESULT failure-result)

automatically generated writer method

Source

asserts.lisp (file)

Generic Function: all-warnings IT
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: all-warnings (N null)
Method: all-warnings (U test-result)
Method: all-warnings (U test-results-db)
Generic Function: args OBJECT
Generic Function: (setf args) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: args (TEST-RESULTS-DB test-results-db)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf args) NEW-VALUE (TEST-RESULTS-DB test-results-db)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: assert-passes? TYPE TEST EXPECTED ACTUAL

Return the result of the assertion.

Package

lisp-unit2

Source

asserts.lisp (file)

Methods
Method: assert-passes? TYPE TEST EXPECTED ACTUAL
Generic Function: assertion CONDITION
Generic Function: (setf assertion) NEW-VALUE CONDITION
Package

lisp-unit2

Methods
Method: assertion (CONDITION assertion-fail)
Method: (setf assertion) NEW-VALUE (CONDITION assertion-fail)
Source

asserts.lisp (file)

Method: assertion (CONDITION assertion-pass)
Method: (setf assertion) NEW-VALUE (CONDITION assertion-pass)
Source

asserts.lisp (file)

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

lisp-unit2

Methods
Method: code (UNIT-TEST unit-test)
Method: (setf code) NEW-VALUE (UNIT-TEST unit-test)

The forms to produce the fn

Source

lisp-unit.lisp (file)

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

lisp-unit2

Methods
Method: contexts (UNIT-TEST-CONTROL-MIXIN unit-test-control-mixin)
Method: (setf contexts) NEW-VALUE (UNIT-TEST-CONTROL-MIXIN unit-test-control-mixin)

A function that accepts a test thunk and executes
with a given context (eg: database-connects, html-collectors, http-context etc)

Source

lisp-unit.lisp (file)

Generic Function: convert-test-result INPUT &optional NAME

Convert the test results from a given test system to lisp-unit2:test-results-db

Package

lisp-unit2

Source

interop.lisp (file)

Generic Function: convert-test-results INPUT TEST-SYSTEM-NAME

Convert the test results from a given test system to lisp-unit2:test-results-db

Package

lisp-unit2

Source

interop.lisp (file)

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

lisp-unit2

Methods
Method: data (UNIT-TEST-CONTROL-MIXIN unit-test-control-mixin)
Method: (setf data) NEW-VALUE (UNIT-TEST-CONTROL-MIXIN unit-test-control-mixin)

Shared data so the context

Source

lisp-unit.lisp (file)

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

lisp-unit2

Methods
Method: doc (UNIT-TEST unit-test)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf doc) NEW-VALUE (UNIT-TEST unit-test)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: end-time OBJECT
Generic Function: (setf end-time) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: end-time (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf end-time) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: eval-package OBJECT
Generic Function: (setf eval-package) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: eval-package (UNIT-TEST unit-test)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf eval-package) NEW-VALUE (UNIT-TEST unit-test)

automatically generated writer method

Source

lisp-unit.lisp (file)

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

lisp-unit2

Methods
Method: expected (FAILURE-RESULT failure-result)

automatically generated reader method

Source

asserts.lisp (file)

Method: (setf expected) NEW-VALUE (FAILURE-RESULT failure-result)

automatically generated writer method

Source

asserts.lisp (file)

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

lisp-unit2

Methods
Method: extras (FAILURE-RESULT failure-result)

automatically generated reader method

Source

asserts.lisp (file)

Method: (setf extras) NEW-VALUE (FAILURE-RESULT failure-result)

automatically generated writer method

Source

asserts.lisp (file)

Generic Function: failed-assertions IT
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: failed-assertions (N null)
Method: failed-assertions (U test-result)
Method: failed-assertions (U test-results-db)
Generic Function: failure CONDITION
Generic Function: (setf failure) NEW-VALUE CONDITION
Package

lisp-unit2

Methods
Method: failure (CONDITION assertion-fail)
Method: (setf failure) NEW-VALUE (CONDITION assertion-fail)
Source

asserts.lisp (file)

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

lisp-unit2

Methods
Method: form (FAILURE-RESULT failure-result)

automatically generated reader method

Source

asserts.lisp (file)

Method: (setf form) NEW-VALUE (FAILURE-RESULT failure-result)

automatically generated writer method

Source

asserts.lisp (file)

Generic Function: head L
Package

lisp-unit2

Source

collectors.lisp (file)

Writer

(setf head) (generic function)

Methods
Method: head (LIST-COLLECTOR list-collector)

automatically generated reader method

Method: head L
Generic Function: (setf head) NEW-VALUE OBJECT
Package

lisp-unit2

Reader

head (generic function)

Methods
Method: (setf head) NEW-VALUE (LIST-COLLECTOR list-collector)

automatically generated writer method

Source

collectors.lisp (file)

Generic Function: install-test UNIT-TEST

Installs a unit test, generally only called from define-test

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: install-test (U unit-test) &aux PACKAGE DB
Generic Function: internal-end-time OBJECT
Generic Function: (setf internal-end-time) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: internal-end-time (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf internal-end-time) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: internal-start-time OBJECT
Generic Function: (setf internal-start-time) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: internal-start-time (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf internal-start-time) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: len L
Package

lisp-unit2

Source

collectors.lisp (file)

Writer

(setf len) (generic function)

Methods
Method: len (LIST-COLLECTOR list-collector)

automatically generated reader method

Method: len L
Generic Function: (setf len) NEW-VALUE OBJECT
Package

lisp-unit2

Reader

len (generic function)

Methods
Method: (setf len) NEW-VALUE (LIST-COLLECTOR list-collector)

automatically generated writer method

Source

collectors.lisp (file)

Generic Function: most-recent-result OBJECT
Generic Function: (setf most-recent-result) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: most-recent-result (UNIT-TEST unit-test)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf most-recent-result) NEW-VALUE (UNIT-TEST unit-test)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: name CONDITION
Generic Function: (setf name) NEW-VALUE CONDITION
Package

lisp-unit2

Methods
Method: name (O test-results-db)
Method: (setf name) NEW (O test-results-db)
Source

lisp-unit.lisp (file)

Method: name (UNIT-TEST unit-test)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf name) NEW-VALUE (UNIT-TEST unit-test)

automatically generated writer method

Source

lisp-unit.lisp (file)

Method: name (CONDITION all-tests-complete)
Method: (setf name) NEW-VALUE (CONDITION all-tests-complete)
Source

vars.lisp (file)

Generic Function: name-index OBJECT
Generic Function: (setf name-index) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: name-index (TEST-DATABASE test-database)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf name-index) NEW-VALUE (TEST-DATABASE test-database)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: package-index OBJECT
Generic Function: (setf package-index) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: package-index (TEST-DATABASE test-database)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf package-index) NEW-VALUE (TEST-DATABASE test-database)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: package-names DB
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: package-names (O test-results-db)
Generic Function: passed-assertions IT
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: passed-assertions (N null)
Method: passed-assertions (U test-result)
Method: passed-assertions (U test-results-db)
Generic Function: record-failure TYPE FORM ACTUAL EXPECTED EXTRAS TEST

Record the details of the failure.

Package

lisp-unit2

Source

asserts.lisp (file)

Methods
Method: record-failure TYPE FORM ACTUAL EXPECTED EXTRAS TEST
Generic Function: record-result RESULT DB
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: record-result (RES test-result) (DB test-results-db) &aux STATUS
Generic Function: result CONDITION
Generic Function: (setf result) NEW-VALUE CONDITION
Package

lisp-unit2

Methods
Method: result (CONDITION test-complete)
Method: (setf result) NEW-VALUE (CONDITION test-complete)
Source

vars.lisp (file)

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

lisp-unit2

Methods
Method: return-value (TEST-RESULT test-result)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf return-value) NEW-VALUE (TEST-RESULT test-result)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: run-time IT
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: run-time (O test-results-mixin)
Generic Function: start-time OBJECT
Generic Function: (setf start-time) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: start-time (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf start-time) NEW-VALUE (TEST-RESULTS-MIXIN test-results-mixin)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: tag-index OBJECT
Generic Function: (setf tag-index) NEW-VALUE OBJECT
Package

lisp-unit2

Methods
Method: tag-index (TEST-DATABASE test-database)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf tag-index) NEW-VALUE (TEST-DATABASE test-database)

automatically generated writer method

Source

lisp-unit.lisp (file)

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

lisp-unit2

Methods
Method: tags (UNIT-TEST unit-test)

automatically generated reader method

Source

lisp-unit.lisp (file)

Method: (setf tags) NEW-VALUE (UNIT-TEST unit-test)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: tags-package-name CONDITION
Package

lisp-unit2

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

lisp-unit.lisp (file)

Generic Function: tail L
Package

lisp-unit2

Source

collectors.lisp (file)

Writer

(setf tail) (generic function)

Methods
Method: tail (LIST-COLLECTOR list-collector)

automatically generated reader method

Method: tail L
Generic Function: (setf tail) NEW-VALUE OBJECT
Package

lisp-unit2

Reader

tail (generic function)

Methods
Method: (setf tail) NEW-VALUE (LIST-COLLECTOR list-collector)

automatically generated writer method

Source

collectors.lisp (file)

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

lisp-unit2

Methods
Method: test (FAILURE-RESULT failure-result)

automatically generated reader method

Source

asserts.lisp (file)

Method: (setf test) NEW-VALUE (FAILURE-RESULT failure-result)

automatically generated writer method

Source

asserts.lisp (file)

Generic Function: test-asdf-system-recursive SYS-NAME &key IGNORE-SYSTEMS
Package

lisp-unit2

Source

interop.lisp (file)

Methods
Method: test-asdf-system-recursive SYS-NAME &key IGNORE-SYSTEMS &aux OUT
Generic Function: test-name CONDITION
Generic Function: (setf test-name) NEW-VALUE CONDITION
Package

lisp-unit2

Methods
Method: test-name (CONDITION missing-test)
Method: (setf test-name) NEW-VALUE (CONDITION missing-test)
Source

vars.lisp (file)

Generic Function: test-thunk UNIT-TEST
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: test-thunk (U unit-test)
Generic Function: test-thunk-name TEST
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: test-thunk-name (U unit-test)
Method: test-thunk-name (U symbol)
Generic Function: tests DB
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Writer

(setf tests) (generic function)

Methods
Method: tests (TEST-RESULTS-DB test-results-db)

automatically generated reader method

Method: tests (DB test-database)
Generic Function: (setf tests) NEW-VALUE OBJECT
Package

lisp-unit2

Reader

tests (generic function)

Methods
Method: (setf tests) NEW-VALUE (TEST-RESULTS-DB test-results-db)

automatically generated writer method

Source

lisp-unit.lisp (file)

Generic Function: tests-package-name CONDITION
Package

lisp-unit2

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

lisp-unit.lisp (file)

Generic Function: tests-with-status DB STATUS

Retrieve all tests with a given status from the database

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Methods
Method: tests-with-status (DBS list) STATUS
Method: tests-with-status (DB test-results-db) STATUS

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

5.2.5 Conditions

Condition: null-tags-warning ()
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses

simple-warning (condition)

Direct methods

tags-package-name (method)

Direct slots
Slot: name
Initargs

:name

Readers

tags-package-name (generic function)

Condition: null-tests-warning ()
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses

simple-warning (condition)

Direct methods

tests-package-name (method)

Direct slots
Slot: name
Initargs

:name

Readers

tests-package-name (generic function)

Condition: test-name-error ()

The test name error is a type error.

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses

type-error (condition)

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

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

5.2.6 Classes

Class: equal-result ()

Result of a failed equal assertion.

Package

lisp-unit2

Source

asserts.lisp (file)

Direct superclasses

failure-result (class)

Class: error-result ()

Result of a failed error assertion.

Package

lisp-unit2

Source

asserts.lisp (file)

Direct superclasses

failure-result (class)

Direct methods

%print-summary (method)

Class: list-collector ()
Package

lisp-unit2

Source

collectors.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: head
Initargs

:head

Readers

head (generic function)

Writers

(setf head) (generic function)

Slot: tail
Initargs

:tail

Readers

tail (generic function)

Writers

(setf tail) (generic function)

Slot: len
Initargs

:len

Initform

0

Readers

len (generic function)

Writers

(setf len) (generic function)

Class: macro-result ()

Result of a failed macro expansion assertion.

Package

lisp-unit2

Source

asserts.lisp (file)

Direct superclasses

failure-result (class)

Direct methods

%print-summary (method)

Class: output-result ()

Result of a failed output assertion.

Package

lisp-unit2

Source

asserts.lisp (file)

Direct superclasses

failure-result (class)

Direct methods

%print-summary (method)

Class: signal-result ()

Result of a failed warning assertion.

Package

lisp-unit2

Source

asserts.lisp (file)

Direct superclasses

failure-result (class)

Class: test-database ()
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: %tests
Initargs

:%tests

Readers

%tests (generic function)

Writers

(setf %tests) (generic function)

Slot: name-index
Initargs

:name-index

Initform

(make-hash-table)

Readers

name-index (generic function)

Writers

(setf name-index) (generic function)

Slot: package-index
Initargs

:package-index

Initform

(make-hash-table)

Readers

package-index (generic function)

Writers

(setf package-index) (generic function)

Slot: tag-index
Initargs

:tag-index

Initform

(make-hash-table)

Readers

tag-index (generic function)

Writers

(setf tag-index) (generic function)

Class: test-results-mixin ()
Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: start-time
Initargs

:start-time

Initform

(get-universal-time)

Readers

start-time (generic function)

Writers

(setf start-time) (generic function)

Slot: internal-start-time
Initargs

:internal-start-time

Initform

(get-internal-real-time)

Readers

internal-start-time (generic function)

Writers

(setf internal-start-time) (generic function)

Slot: end-time
Initargs

:end-time

Readers

end-time (generic function)

Writers

(setf end-time) (generic function)

Slot: internal-end-time
Initargs

:internal-end-time

Readers

internal-end-time (generic function)

Writers

(setf internal-end-time) (generic function)

Slot: errors
Readers

errors (generic function)

Writers

(setf errors) (generic function)

Slot: failed
Readers

failed (generic function)

Writers

(setf failed) (generic function)

Slot: warnings
Readers

warnings (generic function)

Writers

(setf warnings) (generic function)

Slot: passed
Readers

passed (generic function)

Writers

(setf passed) (generic function)

Slot: missing
Readers

missing (generic function)

Writers

(setf missing) (generic function)

Slot: empty
Readers

empty (generic function)

Writers

(setf empty) (generic function)

Class: unit-test-control-mixin ()

Helps commonize test construction by providing a shared data and dynamic context

Package

lisp-unit2

Source

lisp-unit.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
  • data (method)
  • data (method)
  • contexts (method)
  • contexts (method)
Direct slots
Slot: contexts

A function that accepts a test thunk and executes
with a given context (eg: database-connects, html-collectors, http-context etc)

Initargs

:contexts

Readers

contexts (generic function)

Writers

(setf contexts) (generic function)

Slot: data

Shared data so the context

Initargs

:data

Readers

data (generic function)

Writers

(setf data) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L  
Index Entry  Section

F
File, Lisp, lisp-unit2.asd: The lisp-unit2<dot>asd file
File, Lisp, lisp-unit2/assert-package.lisp: The lisp-unit2/assert-package<dot>lisp file
File, Lisp, lisp-unit2/asserts.lisp: The lisp-unit2/asserts<dot>lisp file
File, Lisp, lisp-unit2/collectors.lisp: The lisp-unit2/collectors<dot>lisp file
File, Lisp, lisp-unit2/floating-point.lisp: The lisp-unit2/floating-point<dot>lisp file
File, Lisp, lisp-unit2/interop.lisp: The lisp-unit2/interop<dot>lisp file
File, Lisp, lisp-unit2/lisp-unit.lisp: The lisp-unit2/lisp-unit<dot>lisp file
File, Lisp, lisp-unit2/package.lisp: The lisp-unit2/package<dot>lisp file
File, Lisp, lisp-unit2/rational.lisp: The lisp-unit2/rational<dot>lisp file
File, Lisp, lisp-unit2/summarize.lisp: The lisp-unit2/summarize<dot>lisp file
File, Lisp, lisp-unit2/test-anything-protocol.lisp: The lisp-unit2/test-anything-protocol<dot>lisp file
File, Lisp, lisp-unit2/vars.lisp: The lisp-unit2/vars<dot>lisp file

L
Lisp File, lisp-unit2.asd: The lisp-unit2<dot>asd file
Lisp File, lisp-unit2/assert-package.lisp: The lisp-unit2/assert-package<dot>lisp file
Lisp File, lisp-unit2/asserts.lisp: The lisp-unit2/asserts<dot>lisp file
Lisp File, lisp-unit2/collectors.lisp: The lisp-unit2/collectors<dot>lisp file
Lisp File, lisp-unit2/floating-point.lisp: The lisp-unit2/floating-point<dot>lisp file
Lisp File, lisp-unit2/interop.lisp: The lisp-unit2/interop<dot>lisp file
Lisp File, lisp-unit2/lisp-unit.lisp: The lisp-unit2/lisp-unit<dot>lisp file
Lisp File, lisp-unit2/package.lisp: The lisp-unit2/package<dot>lisp file
Lisp File, lisp-unit2/rational.lisp: The lisp-unit2/rational<dot>lisp file
Lisp File, lisp-unit2/summarize.lisp: The lisp-unit2/summarize<dot>lisp file
Lisp File, lisp-unit2/test-anything-protocol.lisp: The lisp-unit2/test-anything-protocol<dot>lisp file
Lisp File, lisp-unit2/vars.lisp: The lisp-unit2/vars<dot>lisp file
lisp-unit2.asd: The lisp-unit2<dot>asd file
lisp-unit2/assert-package.lisp: The lisp-unit2/assert-package<dot>lisp file
lisp-unit2/asserts.lisp: The lisp-unit2/asserts<dot>lisp file
lisp-unit2/collectors.lisp: The lisp-unit2/collectors<dot>lisp file
lisp-unit2/floating-point.lisp: The lisp-unit2/floating-point<dot>lisp file
lisp-unit2/interop.lisp: The lisp-unit2/interop<dot>lisp file
lisp-unit2/lisp-unit.lisp: The lisp-unit2/lisp-unit<dot>lisp file
lisp-unit2/package.lisp: The lisp-unit2/package<dot>lisp file
lisp-unit2/rational.lisp: The lisp-unit2/rational<dot>lisp file
lisp-unit2/summarize.lisp: The lisp-unit2/summarize<dot>lisp file
lisp-unit2/test-anything-protocol.lisp: The lisp-unit2/test-anything-protocol<dot>lisp file
lisp-unit2/vars.lisp: The lisp-unit2/vars<dot>lisp file

Jump to:   F   L  

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

A.2 Functions

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

%
%array-error: Internal functions
%array-indices: Internal functions
%collect: Internal generic functions
%collect: Internal generic functions
%collect: Internal generic functions
%collect!: Internal macros
%collect-new: Internal generic functions
%collect-new: Internal generic functions
%collect-new: Internal generic functions
%collect-new!: Internal macros
%compile: Internal generic functions
%compile: Internal generic functions
%complex-float-random: Internal functions
%complex-rational-random: Internal functions
%decollect: Internal generic functions
%decollect: Internal generic functions
%decollect: Internal generic functions
%decollect!: Internal macros
%dequote: Internal functions
%form-equal: Internal functions
%has?: Internal functions
%in-package: Internal functions
%log: Internal macros
%log-around: Internal macros
%norm: Internal generic functions
%norm: Internal generic functions
%norm: Internal generic functions
%norm: Internal generic functions
%norm: Internal generic functions
%norm: Internal generic functions
%norm: Internal generic functions
%norm: Internal generic functions
%norm: Internal generic functions
%norm-equal: Internal functions
%normalize-float: Internal functions
%out: Internal functions
%print-result-summary: Internal generic functions
%print-result-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%print-summary: Internal generic functions
%relative-error: Internal functions
%relative-error-norm: Internal functions
%run-test: Internal functions
%run-test-name: Internal functions
%seq-rational-equal: Internal functions
%seq-sigfig-equal: Internal functions
%sequence-equal: Internal functions
%sequence-error: Internal functions
%sigfig-equal: Internal functions
%tests: Internal generic functions
%tests: Internal generic functions
%to-test: Internal functions
%ts: Internal functions
%uninstall-name: Internal functions
%write-tap-test-result: Internal functions

(
(setf %tests): Internal generic functions
(setf %tests): Internal generic functions
(setf actual): Internal generic functions
(setf actual): Internal generic functions
(setf args): Internal generic functions
(setf args): Internal generic functions
(setf assertion): Internal generic functions
(setf assertion): Internal generic functions
(setf assertion): Internal generic functions
(setf code): Internal generic functions
(setf code): Internal generic functions
(setf contexts): Internal generic functions
(setf contexts): Internal generic functions
(setf data): Internal generic functions
(setf data): Internal generic functions
(setf doc): Internal generic functions
(setf doc): Internal generic functions
(setf empty): Exported generic functions
(setf empty): Exported generic functions
(setf end-time): Internal generic functions
(setf end-time): Internal generic functions
(setf errors): Exported generic functions
(setf errors): Exported generic functions
(setf eval-package): Internal generic functions
(setf eval-package): Internal generic functions
(setf expected): Internal generic functions
(setf expected): Internal generic functions
(setf extras): Internal generic functions
(setf extras): Internal generic functions
(setf failed): Exported generic functions
(setf failed): Exported generic functions
(setf failure): Internal generic functions
(setf failure): Internal generic functions
(setf form): Internal generic functions
(setf form): Internal generic functions
(setf head): Internal generic functions
(setf head): Internal generic functions
(setf internal-end-time): Internal generic functions
(setf internal-end-time): Internal generic functions
(setf internal-start-time): Internal generic functions
(setf internal-start-time): Internal generic functions
(setf len): Internal generic functions
(setf len): Internal generic functions
(setf missing): Exported generic functions
(setf missing): Exported generic functions
(setf most-recent-result): Internal generic functions
(setf most-recent-result): Internal generic functions
(setf name): Internal generic functions
(setf name): Internal generic functions
(setf name): Internal generic functions
(setf name): Internal generic functions
(setf name-index): Internal generic functions
(setf name-index): Internal generic functions
(setf package-index): Internal generic functions
(setf package-index): Internal generic functions
(setf passed): Exported generic functions
(setf passed): Exported generic functions
(setf result): Internal generic functions
(setf result): Internal generic functions
(setf results): Exported generic functions
(setf results): Exported generic functions
(setf results): Exported generic functions
(setf results): Exported generic functions
(setf results): Exported generic functions
(setf return-value): Internal generic functions
(setf return-value): Internal generic functions
(setf start-time): Internal generic functions
(setf start-time): Internal generic functions
(setf tag-index): Internal generic functions
(setf tag-index): Internal generic functions
(setf tags): Internal generic functions
(setf tags): Internal generic functions
(setf tail): Internal generic functions
(setf tail): Internal generic functions
(setf test): Internal generic functions
(setf test): Internal generic functions
(setf test-name): Internal generic functions
(setf test-name): Internal generic functions
(setf tests): Internal generic functions
(setf tests): Internal generic functions
(setf unit-test): Exported generic functions
(setf unit-test): Exported generic functions
(setf unit-test): Exported generic functions
(setf unit-test): Exported generic functions
(setf unit-test): Exported generic functions
(setf unit-test): Exported generic functions
(setf warnings): Exported generic functions
(setf warnings): Exported generic functions

A
actual: Internal generic functions
actual: Internal generic functions
all-warnings: Internal generic functions
all-warnings: Internal generic functions
all-warnings: Internal generic functions
all-warnings: Internal generic functions
args: Internal generic functions
args: Internal generic functions
array-error: Exported functions
assert-eq: Exported macros
assert-eql: Exported macros
assert-equal: Exported macros
assert-equality: Exported macros
assert-equalp: Exported macros
assert-error: Exported macros
assert-expands: Exported macros
assert-false: Exported macros
assert-float-equal: Exported macros
assert-no-error: Exported macros
assert-no-signal: Exported macros
assert-no-warning: Exported macros
assert-norm-equal: Exported macros
assert-number-equal: Exported macros
assert-numerical-equal: Exported macros
assert-passes?: Internal generic functions
assert-passes?: Internal generic functions
assert-prints: Exported macros
assert-rational-equal: Exported macros
assert-sigfig-equal: Exported macros
assert-signal: Exported macros
assert-true: Exported macros
assert-typep: Exported macros
assert-warning: Exported macros
assertion: Internal generic functions
assertion: Internal generic functions
assertion: Internal generic functions

C
code: Internal generic functions
code: Internal generic functions
combine-contexts: Internal functions
complex-random: Exported functions
contexts: Internal generic functions
contexts: Internal generic functions
convert-test-result: Internal generic functions
convert-test-results: Internal generic functions

D
data: Internal generic functions
data: Internal generic functions
default-epsilon: Exported generic functions
default-epsilon: Exported generic functions
define-test: Exported macros
do-contexts: Internal functions
doc: Internal generic functions
doc: Internal generic functions

E
empty: Exported generic functions
empty: Exported generic functions
end-time: Internal generic functions
end-time: Internal generic functions
errors: Exported generic functions
errors: Exported generic functions
eval-package: Internal generic functions
eval-package: Internal generic functions
expand-assert: Internal macros
expand-extras: Internal macros
expand-macro-form: Internal macros
expand-output-form: Internal macros
expand-signaled-handler: Internal functions
expected: Internal generic functions
expected: Internal generic functions
extras: Internal generic functions
extras: Internal generic functions

F
failed: Exported generic functions
failed: Exported generic functions
failed-assertions: Internal generic functions
failed-assertions: Internal generic functions
failed-assertions: Internal generic functions
failed-assertions: Internal generic functions
failure: Internal generic functions
failure: Internal generic functions
float-equal: Exported generic functions
float-equal: Exported generic functions
form: Internal generic functions
form: Internal generic functions
Function, %array-error: Internal functions
Function, %array-indices: Internal functions
Function, %complex-float-random: Internal functions
Function, %complex-rational-random: Internal functions
Function, %dequote: Internal functions
Function, %form-equal: Internal functions
Function, %has?: Internal functions
Function, %in-package: Internal functions
Function, %norm-equal: Internal functions
Function, %normalize-float: Internal functions
Function, %out: Internal functions
Function, %relative-error: Internal functions
Function, %relative-error-norm: Internal functions
Function, %run-test: Internal functions
Function, %run-test-name: Internal functions
Function, %seq-rational-equal: Internal functions
Function, %seq-sigfig-equal: Internal functions
Function, %sequence-equal: Internal functions
Function, %sequence-error: Internal functions
Function, %sigfig-equal: Internal functions
Function, %to-test: Internal functions
Function, %ts: Internal functions
Function, %uninstall-name: Internal functions
Function, %write-tap-test-result: Internal functions
Function, array-error: Exported functions
Function, combine-contexts: Internal functions
Function, complex-random: Exported functions
Function, do-contexts: Internal functions
Function, expand-signaled-handler: Internal functions
Function, get-system-list: Internal functions
Function, get-tests: Exported functions
Function, internal-assert: Internal functions
Function, list-tags: Exported functions
Function, list-tests: Exported functions
Function, logically-equal: Exported functions
Function, make-2d-list: Exported functions
Function, make-random-2d-array: Exported functions
Function, make-random-2d-list: Exported functions
Function, make-random-list: Exported functions
Function, null-tags-warning-report: Internal functions
Function, null-tests-warning-report: Internal functions
Function, number-equal: Exported functions
Function, print-failure-summary: Exported functions
Function, print-summary: Exported functions
Function, print-tap: Internal functions
Function, record-result-context: Internal functions
Function, remove-tags: Exported functions
Function, remove-tests: Exported functions
Function, reset-test-database: Exported functions
Function, sequence-error: Internal functions
Function, set-equal: Exported functions
Function, short-full-name: Internal functions
Function, status: Internal functions
Function, test-code: Exported functions
Function, test-documentation: Exported functions
Function, test-name-error-report: Internal functions
Function, test-signals-muffled-context: Internal functions
Function, valid-test-name: Internal functions
Function, with-assertion-summary-context: Exported functions
Function, with-failure-debugging-context: Exported functions
Function, with-summary-context: Exported functions
Function, with-tap-context: Exported functions
Function, with-test-results-context: Exported functions
Function, write-tap: Exported functions
Function, write-tap-to-file: Exported functions

G
Generic Function, %collect: Internal generic functions
Generic Function, %collect-new: Internal generic functions
Generic Function, %compile: Internal generic functions
Generic Function, %decollect: Internal generic functions
Generic Function, %norm: Internal generic functions
Generic Function, %print-result-summary: Internal generic functions
Generic Function, %print-summary: Internal generic functions
Generic Function, %tests: Internal generic functions
Generic Function, (setf %tests): Internal generic functions
Generic Function, (setf actual): Internal generic functions
Generic Function, (setf args): Internal generic functions
Generic Function, (setf assertion): Internal generic functions
Generic Function, (setf code): Internal generic functions
Generic Function, (setf contexts): Internal generic functions
Generic Function, (setf data): Internal generic functions
Generic Function, (setf doc): Internal generic functions
Generic Function, (setf empty): Exported generic functions
Generic Function, (setf end-time): Internal generic functions
Generic Function, (setf errors): Exported generic functions
Generic Function, (setf eval-package): Internal generic functions
Generic Function, (setf expected): Internal generic functions
Generic Function, (setf extras): Internal generic functions
Generic Function, (setf failed): Exported generic functions
Generic Function, (setf failure): Internal generic functions
Generic Function, (setf form): Internal generic functions
Generic Function, (setf head): Internal generic functions
Generic Function, (setf internal-end-time): Internal generic functions
Generic Function, (setf internal-start-time): Internal generic functions
Generic Function, (setf len): Internal generic functions
Generic Function, (setf missing): Exported generic functions
Generic Function, (setf most-recent-result): Internal generic functions
Generic Function, (setf name): Internal generic functions
Generic Function, (setf name-index): Internal generic functions
Generic Function, (setf package-index): Internal generic functions
Generic Function, (setf passed): Exported generic functions
Generic Function, (setf result): Internal generic functions
Generic Function, (setf results): Exported generic functions
Generic Function, (setf return-value): Internal generic functions
Generic Function, (setf start-time): Internal generic functions
Generic Function, (setf tag-index): Internal generic functions
Generic Function, (setf tags): Internal generic functions
Generic Function, (setf tail): Internal generic functions
Generic Function, (setf test): Internal generic functions
Generic Function, (setf test-name): Internal generic functions
Generic Function, (setf tests): Internal generic functions
Generic Function, (setf unit-test): Exported generic functions
Generic Function, (setf warnings): Exported generic functions
Generic Function, actual: Internal generic functions
Generic Function, all-warnings: Internal generic functions
Generic Function, args: Internal generic functions
Generic Function, assert-passes?: Internal generic functions
Generic Function, assertion: Internal generic functions
Generic Function, code: Internal generic functions
Generic Function, contexts: Internal generic functions
Generic Function, convert-test-result: Internal generic functions
Generic Function, convert-test-results: Internal generic functions
Generic Function, data: Internal generic functions
Generic Function, default-epsilon: Exported generic functions
Generic Function, doc: Internal generic functions
Generic Function, empty: Exported generic functions
Generic Function, end-time: Internal generic functions
Generic Function, errors: Exported generic functions
Generic Function, eval-package: Internal generic functions
Generic Function, expected: Internal generic functions
Generic Function, extras: Internal generic functions
Generic Function, failed: Exported generic functions
Generic Function, failed-assertions: Internal generic functions
Generic Function, failure: Internal generic functions
Generic Function, float-equal: Exported generic functions
Generic Function, form: Internal generic functions
Generic Function, head: Internal generic functions
Generic Function, install-test: Internal generic functions
Generic Function, internal-end-time: Internal generic functions
Generic Function, internal-start-time: Internal generic functions
Generic Function, len: Internal generic functions
Generic Function, missing: Exported generic functions
Generic Function, most-recent-result: Internal generic functions
Generic Function, name: Internal generic functions
Generic Function, name-index: Internal generic functions
Generic Function, norm: Exported generic functions
Generic Function, norm-equal: Exported generic functions
Generic Function, numerical-equal: Exported generic functions
Generic Function, package-index: Internal generic functions
Generic Function, package-names: Internal generic functions
Generic Function, passed: Exported generic functions
Generic Function, passed-assertions: Internal generic functions
Generic Function, print-status-summary: Exported generic functions
Generic Function, rational-equal: Exported generic functions
Generic Function, record-failure: Internal generic functions
Generic Function, record-result: Internal generic functions
Generic Function, relative-error: Exported generic functions
Generic Function, relative-error-norm: Exported generic functions
Generic Function, rerun-failures: Exported generic functions
Generic Function, rerun-tests: Exported generic functions
Generic Function, result: Internal generic functions
Generic Function, results: Exported generic functions
Generic Function, return-value: Internal generic functions
Generic Function, run-test: Exported generic functions
Generic Function, run-tests: Exported generic functions
Generic Function, run-time: Internal generic functions
Generic Function, sigfig-equal: Exported generic functions
Generic Function, start-time: Internal generic functions
Generic Function, sump: Exported generic functions
Generic Function, sumsq: Exported generic functions
Generic Function, tag-index: Internal generic functions
Generic Function, tags: Internal generic functions
Generic Function, tags-package-name: Internal generic functions
Generic Function, tail: Internal generic functions
Generic Function, test: Internal generic functions
Generic Function, test-asdf-system-recursive: Internal generic functions
Generic Function, test-name: Internal generic functions
Generic Function, test-thunk: Internal generic functions
Generic Function, test-thunk-name: Internal generic functions
Generic Function, tests: Internal generic functions
Generic Function, tests-package-name: Internal generic functions
Generic Function, tests-with-status: Internal generic functions
Generic Function, uninstall-test: Exported generic functions
Generic Function, unit-test: Exported generic functions
Generic Function, warnings: Exported generic functions
get-system-list: Internal functions
get-tests: Exported functions

H
head: Internal generic functions
head: Internal generic functions
head: Internal generic functions

I
install-test: Internal generic functions
install-test: Internal generic functions
internal-assert: Internal functions
internal-end-time: Internal generic functions
internal-end-time: Internal generic functions
internal-start-time: Internal generic functions
internal-start-time: Internal generic functions

L
len: Internal generic functions
len: Internal generic functions
len: Internal generic functions
list-tags: Exported functions
list-tests: Exported functions
logically-equal: Exported functions

M
Macro, %collect!: Internal macros
Macro, %collect-new!: Internal macros
Macro, %decollect!: Internal macros
Macro, %log: Internal macros
Macro, %log-around: Internal macros
Macro, assert-eq: Exported macros
Macro, assert-eql: Exported macros
Macro, assert-equal: Exported macros
Macro, assert-equality: Exported macros
Macro, assert-equalp: Exported macros
Macro, assert-error: Exported macros
Macro, assert-expands: Exported macros
Macro, assert-false: Exported macros
Macro, assert-float-equal: Exported macros
Macro, assert-no-error: Exported macros
Macro, assert-no-signal: Exported macros
Macro, assert-no-warning: Exported macros
Macro, assert-norm-equal: Exported macros
Macro, assert-number-equal: Exported macros
Macro, assert-numerical-equal: Exported macros
Macro, assert-prints: Exported macros
Macro, assert-rational-equal: Exported macros
Macro, assert-sigfig-equal: Exported macros
Macro, assert-signal: Exported macros
Macro, assert-true: Exported macros
Macro, assert-typep: Exported macros
Macro, assert-warning: Exported macros
Macro, define-test: Exported macros
Macro, expand-assert: Internal macros
Macro, expand-extras: Internal macros
Macro, expand-macro-form: Internal macros
Macro, expand-output-form: Internal macros
Macro, pprint-test-block: Internal macros
Macro, undefine-test: Exported macros
Macro, with-assertion-summary: Exported macros
Macro, with-failure-debugging: Exported macros
Macro, with-summary: Exported macros
Macro, with-tap-summary: Exported macros
Macro, with-test-results: Exported macros
Macro, with-test-signals-muffled: Exported macros
make-2d-list: Exported functions
make-random-2d-array: Exported functions
make-random-2d-list: Exported functions
make-random-list: Exported functions
Method, %collect: Internal generic functions
Method, %collect: Internal generic functions
Method, %collect-new: Internal generic functions
Method, %collect-new: Internal generic functions
Method, %compile: Internal generic functions
Method, %decollect: Internal generic functions
Method, %decollect: Internal generic functions
Method, %norm: Internal generic functions
Method, %norm: Internal generic functions
Method, %norm: Internal generic functions
Method, %norm: Internal generic functions
Method, %norm: Internal generic functions
Method, %norm: Internal generic functions
Method, %norm: Internal generic functions
Method, %norm: Internal generic functions
Method, %print-result-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %print-summary: Internal generic functions
Method, %tests: Internal generic functions
Method, (setf %tests): Internal generic functions
Method, (setf actual): Internal generic functions
Method, (setf args): Internal generic functions
Method, (setf assertion): Internal generic functions
Method, (setf assertion): Internal generic functions
Method, (setf code): Internal generic functions
Method, (setf contexts): Internal generic functions
Method, (setf data): Internal generic functions
Method, (setf doc): Internal generic functions
Method, (setf empty): Exported generic functions
Method, (setf end-time): Internal generic functions
Method, (setf errors): Exported generic functions
Method, (setf eval-package): Internal generic functions
Method, (setf expected): Internal generic functions
Method, (setf extras): Internal generic functions
Method, (setf failed): Exported generic functions
Method, (setf failure): Internal generic functions
Method, (setf form): Internal generic functions
Method, (setf head): Internal generic functions
Method, (setf internal-end-time): Internal generic functions
Method, (setf internal-start-time): Internal generic functions
Method, (setf len): Internal generic functions
Method, (setf missing): Exported generic functions
Method, (setf most-recent-result): Internal generic functions
Method, (setf name): Internal generic functions
Method, (setf name): Internal generic functions
Method, (setf name): Internal generic functions
Method, (setf name-index): Internal generic functions
Method, (setf package-index): Internal generic functions
Method, (setf passed): Exported generic functions
Method, (setf result): Internal generic functions
Method, (setf results): Exported generic functions
Method, (setf results): Exported generic functions
Method, (setf results): Exported generic functions
Method, (setf results): Exported generic functions
Method, (setf return-value): Internal generic functions
Method, (setf start-time): Internal generic functions
Method, (setf tag-index): Internal generic functions
Method, (setf tags): Internal generic functions
Method, (setf tail): Internal generic functions
Method, (setf test): Internal generic functions
Method, (setf test-name): Internal generic functions
Method, (setf tests): Internal generic functions
Method, (setf unit-test): Exported generic functions
Method, (setf unit-test): Exported generic functions
Method, (setf unit-test): Exported generic functions
Method, (setf unit-test): Exported generic functions
Method, (setf unit-test): Exported generic functions
Method, (setf warnings): Exported generic functions
Method, actual: Internal generic functions
Method, all-warnings: Internal generic functions
Method, all-warnings: Internal generic functions
Method, all-warnings: Internal generic functions
Method, args: Internal generic functions
Method, assert-passes?: Internal generic functions
Method, assertion: Internal generic functions
Method, assertion: Internal generic functions
Method, code: Internal generic functions
Method, contexts: Internal generic functions
Method, data: Internal generic functions
Method, default-epsilon: Exported generic functions
Method, doc: Internal generic functions
Method, empty: Exported generic functions
Method, end-time: Internal generic functions
Method, errors: Exported generic functions
Method, eval-package: Internal generic functions
Method, expected: Internal generic functions
Method, extras: Internal generic functions
Method, failed: Exported generic functions
Method, failed-assertions: Internal generic functions
Method, failed-assertions: Internal generic functions
Method, failed-assertions: Internal generic functions
Method, failure: Internal generic functions
Method, float-equal: Exported generic functions
Method, form: Internal generic functions
Method, head: Internal generic functions
Method, head: Internal generic functions
Method, install-test: Internal generic functions
Method, internal-end-time: Internal generic functions
Method, internal-start-time: Internal generic functions
Method, len: Internal generic functions
Method, len: Internal generic functions
Method, missing: Exported generic functions
Method, most-recent-result: Internal generic functions
Method, name: Internal generic functions
Method, name: Internal generic functions
Method, name: Internal generic functions
Method, name-index: Internal generic functions
Method, norm: Exported generic functions
Method, norm: Exported generic functions
Method, norm: Exported generic functions
Method, norm-equal: Exported generic functions
Method, norm-equal: Exported generic functions
Method, norm-equal: Exported generic functions
Method, norm-equal: Exported generic functions
Method, norm-equal: Exported generic functions
Method, numerical-equal: Exported generic functions
Method, numerical-equal: Exported generic functions
Method, numerical-equal: Exported generic functions
Method, numerical-equal: Exported generic functions
Method, numerical-equal: Exported generic functions
Method, numerical-equal: Exported generic functions
Method, package-index: Internal generic functions
Method, package-names: Internal generic functions
Method, passed: Exported generic functions
Method, passed-assertions: Internal generic functions
Method, passed-assertions: Internal generic functions
Method, passed-assertions: Internal generic functions
Method, print-status-summary: Exported generic functions
Method, print-status-summary: Exported generic functions
Method, print-status-summary: Exported generic functions
Method, rational-equal: Exported generic functions
Method, rational-equal: Exported generic functions
Method, rational-equal: Exported generic functions
Method, rational-equal: Exported generic functions
Method, rational-equal: Exported generic functions
Method, rational-equal: Exported generic functions
Method, rational-equal: Exported generic functions
Method, record-failure: Internal generic functions
Method, record-result: Internal generic functions
Method, relative-error: Exported generic functions
Method, relative-error: Exported generic functions
Method, relative-error: Exported generic functions
Method, relative-error: Exported generic functions
Method, relative-error-norm: Exported generic functions
Method, relative-error-norm: Exported generic functions
Method, relative-error-norm: Exported generic functions
Method, relative-error-norm: Exported generic functions
Method, relative-error-norm: Exported generic functions
Method, rerun-failures: Exported generic functions
Method, rerun-failures: Exported generic functions
Method, rerun-tests: Exported generic functions
Method, rerun-tests: Exported generic functions
Method, result: Internal generic functions
Method, results: Exported generic functions
Method, results: Exported generic functions
Method, results: Exported generic functions
Method, results: Exported generic functions
Method, return-value: Internal generic functions
Method, run-test: Exported generic functions
Method, run-test: Exported generic functions
Method, run-test: Exported generic functions
Method, run-tests: Exported generic functions
Method, run-tests: Exported generic functions
Method, run-time: Internal generic functions
Method, sigfig-equal: Exported generic functions
Method, sigfig-equal: Exported generic functions
Method, sigfig-equal: Exported generic functions
Method, sigfig-equal: Exported generic functions
Method, sigfig-equal: Exported generic functions
Method, sigfig-equal: Exported generic functions
Method, start-time: Internal generic functions
Method, sump: Exported generic functions
Method, sump: Exported generic functions
Method, sump: Exported generic functions
Method, sumsq: Exported generic functions
Method, sumsq: Exported generic functions
Method, sumsq: Exported generic functions
Method, tag-index: Internal generic functions
Method, tags: Internal generic functions
Method, tags-package-name: Internal generic functions
Method, tail: Internal generic functions
Method, tail: Internal generic functions
Method, test: Internal generic functions
Method, test-asdf-system-recursive: Internal generic functions
Method, test-name: Internal generic functions
Method, test-thunk: Internal generic functions
Method, test-thunk-name: Internal generic functions
Method, test-thunk-name: Internal generic functions
Method, tests: Internal generic functions
Method, tests: Internal generic functions
Method, tests-package-name: Internal generic functions
Method, tests-with-status: Internal generic functions
Method, tests-with-status: Internal generic functions
Method, uninstall-test: Exported generic functions
Method, uninstall-test: Exported generic functions
Method, unit-test: Exported generic functions
Method, unit-test: Exported generic functions
Method, unit-test: Exported generic functions
Method, unit-test: Exported generic functions
Method, unit-test: Exported generic functions
Method, warnings: Exported generic functions
missing: Exported generic functions
missing: Exported generic functions
most-recent-result: Internal generic functions
most-recent-result: Internal generic functions

N
name: Internal generic functions
name: Internal generic functions
name: Internal generic functions
name: Internal generic functions
name-index: Internal generic functions
name-index: Internal generic functions
norm: Exported generic functions
norm: Exported generic functions
norm: Exported generic functions
norm: Exported generic functions
norm-equal: Exported generic functions
norm-equal: Exported generic functions
norm-equal: Exported generic functions
norm-equal: Exported generic functions
norm-equal: Exported generic functions
norm-equal: Exported generic functions
null-tags-warning-report: Internal functions
null-tests-warning-report: Internal functions
number-equal: Exported functions
numerical-equal: Exported generic functions
numerical-equal: Exported generic functions
numerical-equal: Exported generic functions
numerical-equal: Exported generic functions
numerical-equal: Exported generic functions
numerical-equal: Exported generic functions
numerical-equal: Exported generic functions

P
package-index: Internal generic functions
package-index: Internal generic functions
package-names: Internal generic functions
package-names: Internal generic functions
passed: Exported generic functions
passed: Exported generic functions
passed-assertions: Internal generic functions
passed-assertions: Internal generic functions
passed-assertions: Internal generic functions
passed-assertions: Internal generic functions
pprint-test-block: Internal macros
print-failure-summary: Exported functions
print-status-summary: Exported generic functions
print-status-summary: Exported generic functions
print-status-summary: Exported generic functions
print-status-summary: Exported generic functions
print-summary: Exported functions
print-tap: Internal functions

R
rational-equal: Exported generic functions
rational-equal: Exported generic functions
rational-equal: Exported generic functions
rational-equal: Exported generic functions
rational-equal: Exported generic functions
rational-equal: Exported generic functions
rational-equal: Exported generic functions
rational-equal: Exported generic functions
record-failure: Internal generic functions
record-failure: Internal generic functions
record-result: Internal generic functions
record-result: Internal generic functions
record-result-context: Internal functions
relative-error: Exported generic functions
relative-error: Exported generic functions
relative-error: Exported generic functions
relative-error: Exported generic functions
relative-error: Exported generic functions
relative-error-norm: Exported generic functions
relative-error-norm: Exported generic functions
relative-error-norm: Exported generic functions
relative-error-norm: Exported generic functions
relative-error-norm: Exported generic functions
relative-error-norm: Exported generic functions
remove-tags: Exported functions
remove-tests: Exported functions
rerun-failures: Exported generic functions
rerun-failures: Exported generic functions
rerun-failures: Exported generic functions
rerun-tests: Exported generic functions
rerun-tests: Exported generic functions
rerun-tests: Exported generic functions
reset-test-database: Exported functions
result: Internal generic functions
result: Internal generic functions
results: Exported generic functions
results: Exported generic functions
results: Exported generic functions
results: Exported generic functions
results: Exported generic functions
return-value: Internal generic functions
return-value: Internal generic functions
run-test: Exported generic functions
run-test: Exported generic functions
run-test: Exported generic functions
run-test: Exported generic functions
run-tests: Exported generic functions
run-tests: Exported generic functions
run-tests: Exported generic functions
run-time: Internal generic functions
run-time: Internal generic functions

S
sequence-error: Internal functions
set-equal: Exported functions
short-full-name: Internal functions
sigfig-equal: Exported generic functions
sigfig-equal: Exported generic functions
sigfig-equal: Exported generic functions
sigfig-equal: Exported generic functions
sigfig-equal: Exported generic functions
sigfig-equal: Exported generic functions
sigfig-equal: Exported generic functions
start-time: Internal generic functions
start-time: Internal generic functions
status: Internal functions
sump: Exported generic functions
sump: Exported generic functions
sump: Exported generic functions
sump: Exported generic functions
sumsq: Exported generic functions
sumsq: Exported generic functions
sumsq: Exported generic functions
sumsq: Exported generic functions

T
tag-index: Internal generic functions
tag-index: Internal generic functions
tags: Internal generic functions
tags: Internal generic functions
tags-package-name: Internal generic functions
tags-package-name: Internal generic functions
tail: Internal generic functions
tail: Internal generic functions
tail: Internal generic functions
test: Internal generic functions
test: Internal generic functions
test-asdf-system-recursive: Internal generic functions
test-asdf-system-recursive: Internal generic functions
test-code: Exported functions
test-documentation: Exported functions
test-name: Internal generic functions
test-name: Internal generic functions
test-name-error-report: Internal functions
test-signals-muffled-context: Internal functions
test-thunk: Internal generic functions
test-thunk: Internal generic functions
test-thunk-name: Internal generic functions
test-thunk-name: Internal generic functions
test-thunk-name: Internal generic functions
tests: Internal generic functions
tests: Internal generic functions
tests: Internal generic functions
tests-package-name: Internal generic functions
tests-package-name: Internal generic functions
tests-with-status: Internal generic functions
tests-with-status: Internal generic functions
tests-with-status: Internal generic functions

U
undefine-test: Exported macros
uninstall-test: Exported generic functions
uninstall-test: Exported generic functions
uninstall-test: Exported generic functions
unit-test: Exported generic functions
unit-test: Exported generic functions
unit-test: Exported generic functions
unit-test: Exported generic functions
unit-test: Exported generic functions
unit-test: Exported generic functions

V
valid-test-name: Internal functions

W
warnings: Exported generic functions
warnings: Exported generic functions
with-assertion-summary: Exported macros
with-assertion-summary-context: Exported functions
with-failure-debugging: Exported macros
with-failure-debugging-context: Exported functions
with-summary: Exported macros
with-summary-context: Exported functions
with-tap-context: Exported functions
with-tap-summary: Exported macros
with-test-results: Exported macros
with-test-results-context: Exported functions
with-test-signals-muffled: Exported macros
write-tap: Exported functions
write-tap-to-file: Exported functions

Jump to:   %   (  
A   C   D   E   F   G   H   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   H   I   L   M   N   P   R   S   T   U   W  
Index Entry  Section

%
%tests: Internal classes

*
*epsilon*: Exported special variables
*log-level*: Internal special variables
*measure*: Exported special variables
*result*: Exported special variables
*results*: Exported special variables
*significant-figures*: Exported special variables
*test-db*: Exported special variables
*test-log-stream*: Internal special variables
*test-stream*: Exported special variables
*unit-test*: Exported special variables

+
+interop-test-result-contexts+: Internal special variables
+statuses+: Internal special variables

A
actual: Exported classes
args: Exported classes
assertion: Exported conditions
assertion: Exported conditions

C
code: Exported classes
contexts: Internal classes

D
data: Internal classes
doc: Exported classes

E
empty: Internal classes
end-time: Internal classes
errors: Internal classes
eval-package: Exported classes
expected: Exported classes
extras: Exported classes

F
failed: Internal classes
failure: Exported conditions
form: Exported classes

H
head: Internal classes

I
internal-end-time: Internal classes
internal-start-time: Internal classes

L
len: Internal classes

M
missing: Internal classes
most-recent-result: Exported classes

N
name: Exported conditions
name: Exported classes
name: Exported classes
name: Internal conditions
name: Internal conditions
name-index: Internal classes

P
package-index: Internal classes
passed: Internal classes

R
result: Exported conditions
results: Exported conditions
results: Exported conditions
results: Exported conditions
results: Exported classes
return-value: Exported classes

S
Slot, %tests: Internal classes
Slot, actual: Exported classes
Slot, args: Exported classes
Slot, assertion: Exported conditions
Slot, assertion: Exported conditions
Slot, code: Exported classes
Slot, contexts: Internal classes
Slot, data: Internal classes
Slot, doc: Exported classes
Slot, empty: Internal classes
Slot, end-time: Internal classes
Slot, errors: Internal classes
Slot, eval-package: Exported classes
Slot, expected: Exported classes
Slot, extras: Exported classes
Slot, failed: Internal classes
Slot, failure: Exported conditions
Slot, form: Exported classes
Slot, head: Internal classes
Slot, internal-end-time: Internal classes
Slot, internal-start-time: Internal classes
Slot, len: Internal classes
Slot, missing: Internal classes
Slot, most-recent-result: Exported classes
Slot, name: Exported conditions
Slot, name: Exported classes
Slot, name: Exported classes
Slot, name: Internal conditions
Slot, name: Internal conditions
Slot, name-index: Internal classes
Slot, package-index: Internal classes
Slot, passed: Internal classes
Slot, result: Exported conditions
Slot, results: Exported conditions
Slot, results: Exported conditions
Slot, results: Exported conditions
Slot, results: Exported classes
Slot, return-value: Exported classes
Slot, start-time: Internal classes
Slot, tag-index: Internal classes
Slot, tags: Exported classes
Slot, tail: Internal classes
Slot, test: Exported classes
Slot, test-name: Exported conditions
Slot, tests: Exported classes
Slot, unit-test: Exported conditions
Slot, unit-test: Exported conditions
Slot, unit-test: Exported conditions
Slot, unit-test: Exported classes
Slot, unit-test: Exported classes
Slot, warnings: Internal classes
Special Variable, *epsilon*: Exported special variables
Special Variable, *log-level*: Internal special variables
Special Variable, *measure*: Exported special variables
Special Variable, *result*: Exported special variables
Special Variable, *results*: Exported special variables
Special Variable, *significant-figures*: Exported special variables
Special Variable, *test-db*: Exported special variables
Special Variable, *test-log-stream*: Internal special variables
Special Variable, *test-stream*: Exported special variables
Special Variable, *unit-test*: Exported special variables
Special Variable, +interop-test-result-contexts+: Internal special variables
Special Variable, +statuses+: Internal special variables
start-time: Internal classes

T
tag-index: Internal classes
tags: Exported classes
tail: Internal classes
test: Exported classes
test-name: Exported conditions
tests: Exported classes

U
unit-test: Exported conditions
unit-test: Exported conditions
unit-test: Exported conditions
unit-test: Exported classes
unit-test: Exported classes

W
warnings: Internal classes

Jump to:   %   *   +  
A   C   D   E   F   H   I   L   M   N   P   R   S   T   U   W  

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

A.4 Data types

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

A
all-tests-complete: Exported conditions
all-tests-start: Exported conditions
assertion-fail: Exported conditions
assertion-pass: Exported conditions

C
Class, equal-result: Internal classes
Class, error-result: Internal classes
Class, failure-result: Exported classes
Class, list-collector: Internal classes
Class, macro-result: Internal classes
Class, output-result: Internal classes
Class, signal-result: Internal classes
Class, test-database: Internal classes
Class, test-result: Exported classes
Class, test-results-db: Exported classes
Class, test-results-mixin: Internal classes
Class, unit-test: Exported classes
Class, unit-test-control-mixin: Internal classes
collect-test-results: Exported conditions
Condition, all-tests-complete: Exported conditions
Condition, all-tests-start: Exported conditions
Condition, assertion-fail: Exported conditions
Condition, assertion-pass: Exported conditions
Condition, collect-test-results: Exported conditions
Condition, missing-test: Exported conditions
Condition, null-tags-warning: Internal conditions
Condition, null-tests-warning: Internal conditions
Condition, test-complete: Exported conditions
Condition, test-name-error: Internal conditions
Condition, test-start: Exported conditions

E
equal-result: Internal classes
error-result: Internal classes

F
failure-result: Exported classes

L
lisp-unit2: The lisp-unit2 system
lisp-unit2: The lisp-unit2 package
lisp-unit2-asserts: The lisp-unit2-asserts package
list-collector: Internal classes

M
macro-result: Internal classes
missing-test: Exported conditions

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

O
output-result: Internal classes

P
Package, lisp-unit2: The lisp-unit2 package
Package, lisp-unit2-asserts: The lisp-unit2-asserts package

S
signal-result: Internal classes
System, lisp-unit2: The lisp-unit2 system

T
test-complete: Exported conditions
test-database: Internal classes
test-name-error: Internal conditions
test-result: Exported classes
test-results-db: Exported classes
test-results-mixin: Internal classes
test-start: Exported conditions

U
unit-test: Exported classes
unit-test-control-mixin: Internal classes

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