The clunit2 Reference Manual

This is the clunit2 Reference Manual, version 0.5.2, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Sep 15 04:48:17 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 clunit2

CLUnit is a Common Lisp unit testing framework.

Maintainer

cage

Author

Tapiwa Gutu

Bug Tracker

https://notabug.org/cage/clunit2/issues

License

MIT

Long Description

CLUnit is a Common Lisp unit testing framework. It is designed to be easy to use so that you can quickly start testing.

CLUnit provides a rich set of features aimed at improving your unit
testing experience:

* Multiple inheritance for test suites allows you to group tests into hierarchies.
* Composes the test results of each test run into a single report.
* Allows redefinition of inline functions and macros without
having to redefine your tests.
* Supports composable test suite fixtures.
* Allows for an interactive testing process which gives you access to the test environment.
* Provides visual feedback of the unit test progress.
* Extensible test reporting. Builtin support for default reporting and TAP output.

Version

0.5.2

Source

clunit2.asd.

Child Component

src (module).


3 Modules

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


3.1 clunit2/src

Source

clunit2.asd.

Parent Component

clunit2 (system).

Child Components

3.2 clunit2/src/classes

Dependency

specials.lisp (file).

Source

clunit2.asd.

Parent Component

src (module).

Child Components

3.3 clunit2/src/functions

Dependency

classes (module).

Source

clunit2.asd.

Parent Component

src (module).

Child Components

3.4 clunit2/src/report-formats

Dependency

functions (module).

Source

clunit2.asd.

Parent Component

src (module).

Child Components

3.5 clunit2/src/macros

Dependency

report-formats (module).

Source

clunit2.asd.

Parent Component

src (module).

Child Components

4 Files

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


4.1 Lisp


4.1.1 clunit2/clunit2.asd

Source

clunit2.asd.

Parent Component

clunit2 (system).

ASDF Systems

clunit2.


4.1.2 clunit2/src/package.lisp

Source

clunit2.asd.

Parent Component

src (module).

Packages

clunit.


4.1.3 clunit2/src/specials.lisp

Dependency

package.lisp (file).

Source

clunit2.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.4 clunit2/src/classes/assertion-conditions.lisp

Source

clunit2.asd.

Parent Component

classes (module).

Internals

4.1.5 clunit2/src/classes/test-suite-failure-conditions.lisp

Source

clunit2.asd.

Parent Component

classes (module).

Internals

4.1.6 clunit2/src/classes/clunit-report.lisp

Source

clunit2.asd.

Parent Component

classes (module).

Public Interface
Internals

4.1.7 clunit2/src/classes/clunit-test-case.lisp

Source

clunit2.asd.

Parent Component

classes (module).

Internals

4.1.8 clunit2/src/classes/clunit-test-suite.lisp

Source

clunit2.asd.

Parent Component

classes (module).

Internals

4.1.9 clunit2/src/classes/clunit-test-report.lisp

Source

clunit2.asd.

Parent Component

classes (module).

Public Interface
Internals

4.1.10 clunit2/src/functions/utilities.lisp

Source

clunit2.asd.

Parent Component

functions (module).

Internals

4.1.11 clunit2/src/functions/prepare-specials.lisp

Source

clunit2.asd.

Parent Component

functions (module).

Internals

with-prepare-specials-for-testing (macro).


4.1.12 clunit2/src/functions/assertion-functions.lisp

Source

clunit2.asd.

Parent Component

functions (module).

Internals

4.1.13 clunit2/src/functions/generic-functions.lisp

Source

clunit2.asd.

Parent Component

functions (module).

Internals

4.1.14 clunit2/src/functions/test-case-functions.lisp

Source

clunit2.asd.

Parent Component

functions (module).

Public Interface
Internals

4.1.15 clunit2/src/functions/test-suite-functions.lisp

Source

clunit2.asd.

Parent Component

functions (module).

Public Interface
Internals

4.1.16 clunit2/src/functions/rerun-failed-tests.lisp

Source

clunit2.asd.

Parent Component

functions (module).

Public Interface

rerun-failed-tests (function).


4.1.17 clunit2/src/functions/progress-report-functions.lisp

Source

clunit2.asd.

Parent Component

functions (module).

Internals

4.1.18 clunit2/src/report-formats/report-format-default.lisp

Source

clunit2.asd.

Parent Component

report-formats (module).

Internals

4.1.19 clunit2/src/report-formats/report-format-tap.lisp

Source

clunit2.asd.

Parent Component

report-formats (module).

Internals

4.1.20 clunit2/src/report-formats/print-object.lisp

Source

clunit2.asd.

Parent Component

report-formats (module).

Public Interface

4.1.21 clunit2/src/macros/utility-macros.lisp

Source

clunit2.asd.

Parent Component

macros (module).

Internals

4.1.22 clunit2/src/macros/assertion-macros.lisp

Dependency

utility-macros.lisp (file).

Source

clunit2.asd.

Parent Component

macros (module).

Public Interface
Internals

4.1.23 clunit2/src/macros/deffixture.lisp

Dependency

assertion-macros.lisp (file).

Source

clunit2.asd.

Parent Component

macros (module).

Public Interface

4.1.24 clunit2/src/macros/defsuite.lisp

Dependency

deffixture.lisp (file).

Source

clunit2.asd.

Parent Component

macros (module).

Public Interface

4.1.25 clunit2/src/macros/deftest.lisp

Dependency

defsuite.lisp (file).

Source

clunit2.asd.

Parent Component

macros (module).

Public Interface
Internals

collect-all-suite-dependencies (function).


5 Packages

Packages are listed by definition order.


5.1 clunit

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Special variables

Special Variable: *clunit-equality-test*

Holds the equality test used to compare values by the ASSERT-EQUALITY macro.<br/> The default value <em>#’equalp</em> is reset at the end of each test/suite run.

Package

clunit.

Source

specials.lisp.

Special Variable: *clunit-report-format*

Controls the output format of the unit test results. Possible values are :default, :tap or NIL.

Package

clunit.

Source

specials.lisp.

Special Variable: *test-output-stream*

The stream where the output made by tests is printed (default to ‘*standard-output*’)

Package

clunit.

Source

specials.lisp.


6.1.2 Macros

Macro: assert-condition (condition expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes if EXPRESSION signals CONDITION. FORMS and their values are printed if the test fails.

Example:

(assert-condition arithmetic-error (/ 1 0)) ; This assertion passes.

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-eq (value expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes if (EQ VALUE EXPRESSION) values non nil. FORMS and their values are printed if the test fails.

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-eql (value expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes if (EQL VALUE EXPRESSION) values non nil. FORMS and their values are printed if the test fails.

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-equal (value expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes if (EQUAL VALUE EXPRESSION) values non nil. FORMS and their values are printed if the test fails.

example
(let ((q (+ 2 -2)))
(assert-equal 4 q q))
;; This assertion fails and prints the message below with ;; *clunit-report-format* set to :DEFAULT.
Expression: (EQUAL 4 Q)
Expected: 4
Returned: 0
Q => 0

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-equality (test value expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes
if (FUNCALL TEST VALUE EXPRESSION) values non nil. FORMS and their
values are printed if the test fails.

Example:

(assert-equality #’string= "some string" "another string") ; This assertion fails.

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-equality* (value expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes
if (FUNCALL *clunit-equality-test* VALUE EXPRESSION) returns
true. FORMS and their values are printed if the test fails.

Example:

(let ((*clunit-equality-test* #’string=))
(assert-equality* "some string" "another string")) ; This assertion fails

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-equalp (value expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes if (EQUALP VALUE EXPRESSION) values non nil. FORMS and their values are printed if the test fails.

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-expands (expansion expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes if (EQUALP EXPANSION (MACROEXPAND-1 EXPRESSION)) values non nil. FORMS and their values are printed if the test fails.

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-false (expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes if it returns nil. FORMS and their values are printed if the test fails.

example:

(assert-false (= 1 2)) ; This assertion passes.

Package

clunit.

Source

assertion-macros.lisp.

Macro: assert-true (expression &body forms)

Evaluates EXPRESSION as an assertion, an assertion passes if it returns any non-NIL value. FORMS and their values are printed if the test fails. Remember in Common Lisp any non-NIL value is true, if you want a strict binary assertion test use (assert-eq t expression) instead.

Example:

(assert-true (= 1 1)) ; This assertion passes.

Package

clunit.

Source

assertion-macros.lisp.

Macro: deffixture (suite (plug) &body body)

A fixture defines a code template that is wrapped around the code of each test case and test suite that are executed by test suite SUITE at runtime.. The test case body is plugged into the template at the position identified by PLUG.

Fixtures are expanded at compile time.

Example:

(deffixture arithmetic (@body) ; @body is the plug
(let ((x 0) (y 1) (z 2))
@body))

Package

clunit.

Source

deffixture.lisp.

Macro: defsuite (name parents)

Defines a test suite called NAME. If PARENTS is non-NIL the test suite is defined as a sub-suite of each of the test suites in PARENTS.

Example:

(defsuite arithmetic ())

(defsuite arithmetic-+ (arithmetic))

Package

clunit.

Source

defsuite.lisp.

Macro: deftest (name declarations &body body)

Defines a test case called NAME. DECLARATIONS declares which test
suites this test case is associated with as well as any other test
cases that it depends on. The test case body is revaluated on each
run, so any redefinition of macros and inline functions will be automatically visible without having to redefine the test.

A test case will be queued until all tests cases it depends on have been run.
If all the test cases pass the queued test is executed otherwise its skipped.

The DEFTEST macro has three possible forms:

- Define a test case not associated with any test suite and with no dependencies.<br/> (deftest name () . body)

- Define a test case which is associated with test suites: suite1 ... suiteN. (deftest name (suite1 suite2 ... suiteN) . body)

- Define a test case associated with test suites: suite1 ... suiteN and
depends on tests: test1 ... testN

(deftest name ((suite1 suite2 ... suiteN) (test1 test2 ... testN)) . body)

Package

clunit.

Source

deftest.lisp.

Macro: undeffixture (name)

Remove a fixture definition.

Package

clunit.

Source

deffixture.lisp.

Macro: undefsuite (name)
Package

clunit.

Source

defsuite.lisp.

Macro: undeftest (name)
Package

clunit.

Source

deftest.lisp.


6.1.3 Ordinary functions

Function: assert-fail (format-string &rest args)

Calling this function is equivalent to signalling a failed assertion. The FORMAT-STRING and ARGS are used to print the failure message as follows:

(format stream "~?" format-string args)

If you want to achieve a nice looking output message, use pretty printing directives in the format string e.g. "~:@_" instead of "%".

Package

clunit.

Source

assertion-macros.lisp.

Function: defined-suite-p (suite-name)

Returns non-nil if a test suite called SUITE-NAME is defined, otherwise returns NIL.

Package

clunit.

Source

test-suite-functions.lisp.

Function: defined-test-p (test-name)

Returns non-nil if a test case called TEST-NAME is defined, otherwise returns NIL.

Package

clunit.

Source

test-case-functions.lisp.

Function: get-child-suites (suite-name)

Returns a list of all test suite names that are children of the suite called SUITE-NAME.

Package

clunit.

Source

test-suite-functions.lisp.

Function: get-child-tests (suite-name)

Returns a list of all test case names that are children of the suite called SUITE-NAME.

Package

clunit.

Source

test-suite-functions.lisp.

Function: get-defined-suites ()

Returns a list of all defined test suite names.

Package

clunit.

Source

test-suite-functions.lisp.

Function: get-defined-tests ()

Returns a list of all defined test case names.

Package

clunit.

Source

test-case-functions.lisp.

Function: rerun-failed-tests (&key use-debugger report-progress stop-on-fail last-report print-results-summary)

Reruns all failed tests recorded in LAST-REPORT which defaults to the report of the previous test run. If REPORT-PROGRESS is non-NIL, the test progress is reported. If USE-DEBUGGER is non-NIL, the debugger is invoked whenever an assertion fails.

If STOP-ON-FAIL is non-NIL, the rest of the unit test is cancelled when any assertion fails or an error occurs.

If PRINT-RESULTS-SUMMARY is non nil the summary results of tests is printed on the standard output.

Package

clunit.

Source

rerun-failed-tests.lisp.

Function: run-suite (suite &key use-debugger report-progress stop-on-fail signal-condition-on-fail print-results-summary)

Executes a test case called SUITE. If REPORT-PROGRESS is non-NIL, the test progress is reported.

If USE-DEBUGGER is non-NIL, the debugger is invoked whenever an assertion fails.

If STOP-ON-FAIL is non-NIL, the rest of the unit test is cancelled when any assertion fails or an error occurs.

if PRINT-RESULTS-SUMMARY is non nil the summary results of tests is printed on the standard output.

Package

clunit.

Source

test-suite-functions.lisp.

Function: run-test (test &key use-debugger report-progress stop-on-fail print-results-summary)

Executes a test case called ‘test’.

If REPORT-PROGRESS is non-NIL, the test progress is reported.

If USE-DEBUGGER is non-NIL, the debugger is invoked whenever an assertion fails.

If STOP-ON-FAIL is non-NIL, the rest of the unit test is cancelled when any assertion fails or an error occurs.

If PRINT-RESULTS-SUMMARY is non nil the summary results of tests is printed on the standard output.

Package

clunit.

Source

test-case-functions.lisp.


6.1.4 Generic functions

Generic Reader: test-report-name (object)
Generic Writer: (setf test-report-name) (object)
Package

clunit.

Methods
Reader Method: test-report-name ((clunit-test-report clunit-test-report))
Writer Method: (setf test-report-name) ((clunit-test-report clunit-test-report))

the reader function is used in test-case-execution-action (see utility functions)

Source

clunit-test-report.lisp.

Target Slot

test-name.

Generic Reader: test-report-passed-p (object)
Package

clunit.

Methods
Reader Method: test-report-passed-p ((clunit-test-report clunit-test-report))

Non-nil if the report passed

Source

clunit-test-report.lisp.

Target Slot

passed-p.

Generic Reader: test-reports (object)
Generic Writer: (setf test-reports) (object)
Package

clunit.

Methods
Reader Method: test-reports ((clunit-report clunit-report))
Writer Method: (setf test-reports) ((clunit-report clunit-report))

A list of ‘cl-test-report’ that contains all the test’s reports

Source

clunit-report.lisp.

Target Slot

test-reports.


6.1.5 Standalone methods

Method: print-object ((clunit-report clunit-report) stream)
Source

print-object.lisp.

Method: print-object ((clunit-test-report clunit-test-report) stream)
Source

print-object.lisp.

Method: print-object ((assertion-condition assertion-condition) stream)
Source

print-object.lisp.


6.1.6 Classes

Class: clunit-report

the clunit-report instance is used to store the
aggregated reports of all executed test cases (returned by ‘run-test’ and ‘rerun-failed-tests’.

Package

clunit.

Source

clunit-report.lisp.

Direct methods
Direct slots
Slot: errors

The number of tests that signalled an error condition during test executions.

Initform

0

Initargs

:errors

Readers

errors.

Writers

(setf errors).

Slot: failed

The number of tests failed during test executions.

Initform

0

Initargs

:failed

Readers

failed.

Writers

(setf failed).

Slot: passed

The number of tests that passed during test executions.

Initform

0

Initargs

:passed

Readers

passed.

Writers

(setf passed).

Slot: skipped

The number of tests that was skipped during test executions.

Initform

0

Initargs

:skipped

Readers

skipped.

Writers

(setf skipped).

Slot: test-reports

A list of ‘cl-test-report’ that contains all the test’s reports

Readers

test-reports.

Writers

(setf test-reports).

Class: clunit-test-report
Package

clunit.

Source

clunit-test-report.lisp.

Direct methods
Direct slots
Slot: test-name

the reader function is used in test-case-execution-action (see utility functions)

Initargs

:test-name

Readers

test-report-name.

Writers

(setf test-report-name).

Slot: passed-p

Non-nil if the report passed

Initform

t

Initargs

:passed-p

Readers

test-report-passed-p.

Writers

(setf test-report-passed).

Slot: skipped-p

Non-nil if the test was skipped

Initargs

:skipped-p

Readers

skipped-p.

Writers

(setf skipped-tests).

Slot: suite-list

A list of the suites this test belong.

Initargs

:suite-list

Readers

suite-list.

Writers

(setf suite-list).

Slot: assertion-conditions

the clunit-test-report instance is used to store the report information for each executed test case.

Initform

(make-array clunit::+assertion-conditions-reserved-size+ :adjustable t :fill-pointer 0)

Readers

assertion-conditions.

Writers

(setf assertion-conditions).


6.2 Internals


6.2.1 Constants

Constant: +assertion-conditions-reserved-size+
Package

clunit.

Source

clunit-test-report.lisp.


6.2.2 Special variables

Special Variable: *clunit-report*

Holds a CLUNIT-REPORT object during a test run, used to store aggregated test reports.

Package

clunit.

Source

specials.lisp.

Special Variable: *clunit-test-report*

Holds a CLUNIT-TEST-REPORT object for each executing test case.

Package

clunit.

Source

specials.lisp.

Special Variable: *last-clunit-report*

Holds the last returned CLUNIT-REPORT object. Default optional argument to the function RERUN-FAILED-TESTS.

Package

clunit.

Source

specials.lisp.

Special Variable: *queued-test-reports*

A list of queued CLUNIT-TEST-REPORT objects whose test case execution has been deferred until their dependencies requirements are met.

Package

clunit.

Source

specials.lisp.

Special Variable: *report-progress*

This variable switches on progress reporting if set to true.

Package

clunit.

Source

specials.lisp.

Special Variable: *stop-on-fail*

If any assertion fails or an error condition occurs, stop the unit test.

Package

clunit.

Source

specials.lisp.

Special Variable: *suite-name*

Holds a list of suite symbol names in their current calling order. First called suite at the front, currently executing suite at the back.

Package

clunit.

Source

specials.lisp.

Special Variable: *tab-width*

Number of tab columns to use for indentation (in the reporting functions).

Package

clunit.

Source

specials.lisp.

Special Variable: *tap-test-num*

Counter used in these printing functions

Package

clunit.

Source

report-format-tap.lisp.

Special Variable: *test-case-hashtable*

Holds CLUNIT-TEST-CASE instances. The key of each test case object is the symbol name.

Package

clunit.

Source

specials.lisp.

Special Variable: *test-name*

Holds the name of the test currently executing.

Package

clunit.

Source

specials.lisp.

Special Variable: *test-suite-alist*

Holds CLUNIT-TEST-SUITE instances. The car of each test suite object is the symbol name.

Package

clunit.

Source

specials.lisp.

Special Variable: *test-suite-hashtable*

Holds CLUNIT-TEST-SUITE instances. The key of each test suite object is the symbol name.

Package

clunit.

Source

specials.lisp.

Special Variable: *use-debugger*

If set to true, the debugger is invoked whenever an assertion fails.

Package

clunit.

Source

specials.lisp.


6.2.3 Macros

Macro: gen-test-form (predicate values results)
Package

clunit.

Source

assertion-macros.lisp.

Macro: with-assert-restart (&body body)

WITH-ASSERT-RESTART places a restart called SKIP-ASSERTION around an assertion form.

Package

clunit.

Source

utility-macros.lisp.

Macro: with-gensyms (syms &body body)

WITH-GENSYMS takes a list of symbols SYM and a list of body forms. It returns a LET clause with each symbol in SYM bound to a gensymbol and the body forms as the body of the let clause.

Package

clunit.

Source

utility-macros.lisp.

Macro: with-prepare-specials-for-testing ((report-progress use-debugger stop-on-fail) &body body)

Set some common special variables to meaningful values to prepare for running tests or suite

Package

clunit.

Source

prepare-specials.lisp.

Macro: with-test-restart (&body body)
Package

clunit.

Source

utility-macros.lisp.


6.2.4 Ordinary functions

Function: add-test-case (name new-test-case)

Adds NEW-TEST-CASE in the hash table *TEST-CASES* under the key NAME.

Package

clunit.

Source

test-case-functions.lisp.

Function: all-symbols-p (list error-control-message)

Ensures ‘list’ is a list of symbols.

In deftest ‘declarations’ can be a list of suites or a list of two elements, the first a list of suites and the second a list of tests, each memebre of said list must be a symbol.

Package

clunit.

Source

utilities.lisp.

Function: assertion-expander (&key result test result-expression report-expression expected forms)

Expands an assertion macro call.

Package

clunit.

Source

assertion-macros.lisp.

Function: collect-all-suite-dependencies (direct-dependency-list)
Package

clunit.

Source

deftest.lisp.

Function: collect-suite-dependencies (start &key symbol-suite-only)
Package

clunit.

Source

clunit-test-suite.lisp.

Function: deftest-declaration-dependencies (declarations)

When ‘declarations’ comes from the ‘deftest’ macro returns the dependencies (suites and optionally tests)

Package

clunit.

Source

utilities.lisp.

Function: delete-test-case (name)

Deletes the TEST-CASE instance associated with the key NAME in the hash table *TEST-CASES*

Package

clunit.

Source

test-case-functions.lisp.

Function: delete-test-suite (name)

Deletes the TEST-SUITE instance associated with the key NAME in the hash table *test-suite-hashtable*

Package

clunit.

Source

test-suite-functions.lisp.

Function: ensure-dependency-exists (name list predicate control-message)
Package

clunit.

Source

utilities.lisp.

Function: execute-test-case (test-case)
Package

clunit.

Source

test-case-functions.lisp.

Function: execute-test-suite (test-suite)
Package

clunit.

Source

test-suite-functions.lisp.

Function: form-expander (forms)

FORM-EXPANDER manipulates the list of forms provided to an assertion form, e.g. (defmacro assert-false (expression &rest forms) . body)

The members of the forms list are printed out when an assertion test fails. The example below, shows the debug output when an assertion form fails.

(let ((x 1) (y 2) (z 3))
;;forms = ’(x y "Comment: This is meant to fail." z) (assert-true (= x y z) x y "Comment: This is meant to fail." z))

======== Debug output ===========
Expression: (= x y z)
Expected: T
Returned: NIL
x => 1
y => 2
Comment: This is meant to fail.
z => 3
==================================
As you can see, the reporting is somehow able to differentiate between the symbols x, y, z and the string comment.
This is achieved by expanding ’(x y "Comment..." z) => (T ’x x T ’y y NIL "Comment..." T ’z z)
The T or NIL symbol tells the reporting function whether to report the next two values as a pair or not.
I went at great lengths to explain this because WHAT the function does is straight forward from the code, but WHY it does it
isn’t too obvious unless someone tells you :o)

Package

clunit.

Source

assertion-macros.lisp.

Function: get-test-case (name)

Retrieves the TEST-CASE instance associated with the key NAME in the hash table *TEST-CASES*

Package

clunit.

Source

test-case-functions.lisp.

Function: get-test-suite (name)

Retrieves the TEST-SUITE instance associated with the key NAME in the hash table *test-suite-hashtable*

Package

clunit.

Source

test-suite-functions.lisp.

Function: (setf get-test-suite) (name)

Adds NEW-TEST-SUITE in the hash table *test-suite-hashtable* and *test-suite-alist* under the key NAME.

Package

clunit.

Source

test-suite-functions.lisp.

Function: handle-assertion (condition)

Records the result of assertion tests and records any errors that occur.

Package

clunit.

Source

assertion-functions.lisp.

Function: handle-error (error)
Package

clunit.

Source

assertion-functions.lisp.

Function: process-queued-tests ()
Package

clunit.

Source

test-case-functions.lisp.

Function: queue-test-case ()

Enqueue a test.

Package

clunit.

Source

test-case-functions.lisp.

Function: report-assertion-progress (type)
Package

clunit.

Source

progress-report-functions.lisp.

Function: report-suite-progress (suite suite-list)
Package

clunit.

Source

progress-report-functions.lisp.

Function: report-test-progress (test-name suite-list)
Package

clunit.

Source

progress-report-functions.lisp.

Function: signal-assertion (type &key expression expected returned forms message format-string args)
Package

clunit.

Source

assertion-functions.lisp.

Function: skip-test-case ()

Skip a test.

Package

clunit.

Source

test-case-functions.lisp.

Function: test-case-execution-action (test-case)

Determines the execution action for TEST-CASE. If test case has no dependencies or pending dependencies, then :RUN is returned.

If test case has another test case it depends on that failed or was skipped, then :SKIP is returned.

If test case depends on test cases that have not yet run or are also queued, then :QUEUE is returned.

Package

clunit.

Source

test-case-functions.lisp.


6.2.5 Generic functions

Generic Reader: assertion-conditions (object)
Generic Writer: (setf assertion-conditions) (object)
Package

clunit.

Methods
Reader Method: assertion-conditions ((clunit-test-report clunit-test-report))
Writer Method: (setf assertion-conditions) ((clunit-test-report clunit-test-report))

the clunit-test-report instance is used to store the report information for each executed test case.

Source

clunit-test-report.lisp.

Target Slot

assertion-conditions.

Generic Reader: child-suites (object)
Package

clunit.

Methods
Reader Method: child-suites ((clunit-test-suite clunit-test-suite))

automatically generated reader method

Source

clunit-test-suite.lisp.

Target Slot

child-suites.

Generic Writer: (setf child-suites) (object)
Package

clunit.

Methods
Writer Method: (setf child-suites) ((clunit-test-suite clunit-test-suite))

automatically generated writer method

Source

clunit-test-suite.lisp.

Target Slot

child-suites.

Generic Reader: dependencies (object)
Generic Writer: (setf dependencies) (object)
Package

clunit.

Methods
Reader Method: dependencies ((clunit-test-case clunit-test-case))
Writer Method: (setf dependencies) ((clunit-test-case clunit-test-case))

The DEPENDENCIES slot holds the names of the test cases that
this test case depends on. Using an indirect reference like this allows us to easily undefine a test case without much cleaning up.

When we execute a test case and we resolve the references of the tests it depends on. If the object is not found it means the reference is now stale, so we remove the name from the list.

Source

clunit-test-case.lisp.

Target Slot

dependencies.

Generic Reader: errors (object)
Generic Writer: (setf errors) (object)
Package

clunit.

Methods
Reader Method: errors ((clunit-report clunit-report))
Writer Method: (setf errors) ((clunit-report clunit-report))

The number of tests that signalled an error condition during test executions.

Source

clunit-report.lisp.

Target Slot

errors.

Generic Function: expand-fixture (suite body)

Expands out a fixture body for the given test suite.

Package

clunit.

Source

generic-functions.lisp.

Methods
Method: expand-fixture (suite body)
Generic Reader: failed (object)
Generic Writer: (setf failed) (object)
Package

clunit.

Methods
Reader Method: failed ((clunit-report clunit-report))
Writer Method: (setf failed) ((clunit-report clunit-report))

The number of tests failed during test executions.

Source

clunit-report.lisp.

Target Slot

failed.

Generic Reader: name (object)
Package

clunit.

Methods
Reader Method: name ((named-class named-class))

automatically generated reader method

Source

clunit-test-case.lisp.

Target Slot

name.

Generic Writer: (setf name) (object)
Package

clunit.

Methods
Writer Method: (setf name) ((named-class named-class))

automatically generated writer method

Source

clunit-test-case.lisp.

Target Slot

name.

Generic Reader: passed (object)
Generic Writer: (setf passed) (object)
Package

clunit.

Methods
Reader Method: passed ((clunit-report clunit-report))
Writer Method: (setf passed) ((clunit-report clunit-report))

The number of tests that passed during test executions.

Source

clunit-report.lisp.

Target Slot

passed.

Generic Function: print-format (object format stream)

Outputs the OBJECT report to STREAM in the given FORMAT. FORMAT can be :default, :tap or NIL.

Package

clunit.

Source

generic-functions.lisp.

Methods
Method: print-format ((condition assertion-fail-forced) (format (eql :tap)) stream)
Source

report-format-tap.lisp.

Method: print-format ((condition assertion-failed) (format (eql :tap)) stream)
Source

report-format-tap.lisp.

Method: print-format ((condition assertion-error) (format (eql :tap)) stream)
Source

report-format-tap.lisp.

Method: print-format ((report clunit-test-report) (format (eql :tap)) stream)
Source

report-format-tap.lisp.

Method: print-format ((clunit-report clunit-report) (format (eql :tap)) stream)
Source

report-format-tap.lisp.

Method: print-format ((condition test-suite-failure-condition) (format (eql :default)) stream)
Source

report-format-default.lisp.

Method: print-format ((condition assertion-fail-forced) (format (eql :default)) stream)
Source

report-format-default.lisp.

Method: print-format ((condition assertion-failed) (format (eql :default)) stream)
Source

report-format-default.lisp.

Method: print-format ((condition assertion-error) (format (eql :default)) stream)
Source

report-format-default.lisp.

Method: print-format ((report clunit-test-report) (format (eql :default)) stream)
Source

report-format-default.lisp.

Method: print-format ((clunit-report clunit-report) (format (eql :default)) stream)
Source

report-format-default.lisp.

Generic Reader: skipped (object)
Generic Writer: (setf skipped) (object)
Package

clunit.

Methods
Reader Method: skipped ((clunit-report clunit-report))
Writer Method: (setf skipped) ((clunit-report clunit-report))

The number of tests that was skipped during test executions.

Source

clunit-report.lisp.

Target Slot

skipped.

Generic Reader: skipped-p (object)
Package

clunit.

Methods
Reader Method: skipped-p ((clunit-test-report clunit-test-report))

Non-nil if the test was skipped

Source

clunit-test-report.lisp.

Target Slot

skipped-p.

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

clunit.

Methods
Writer Method: (setf skipped-tests) ((clunit-test-report clunit-test-report))

Non-nil if the test was skipped

Source

clunit-test-report.lisp.

Target Slot

skipped-p.

Generic Reader: suite-list (object)
Generic Writer: (setf suite-list) (object)
Package

clunit.

Methods
Reader Method: suite-list ((clunit-test-report clunit-test-report))
Writer Method: (setf suite-list) ((clunit-test-report clunit-test-report))

A list of the suites this test belong.

Source

clunit-test-report.lisp.

Target Slot

suite-list.

Generic Reader: test-cases (object)
Generic Writer: (setf test-cases) (object)
Package

clunit.

Methods
Reader Method: test-cases ((clunit-test-suite clunit-test-suite))
Writer Method: (setf test-cases) ((clunit-test-suite clunit-test-suite))

The tests that belongs to this suite (list of symbols)

Source

clunit-test-suite.lisp.

Target Slot

test-cases.

Generic Reader: test-function (object)
Generic Writer: (setf test-function) (object)
Package

clunit.

Methods
Reader Method: test-function ((clunit-test-case clunit-test-case))
Writer Method: (setf test-function) ((clunit-test-case clunit-test-case))

The actual test, a function with no arguments that returns non nil if the test passed

Source

clunit-test-case.lisp.

Target Slot

test-function.

Generic Writer: (setf test-report-passed) (object)
Package

clunit.

Methods
Writer Method: (setf test-report-passed) ((clunit-test-report clunit-test-report))

Non-nil if the report passed

Source

clunit-test-report.lisp.

Target Slot

passed-p.


6.2.6 Conditions

Condition: assertion-condition
Package

clunit.

Source

assertion-conditions.lisp.

Direct superclasses

condition.

Direct subclasses
Direct methods

print-object.

Condition: assertion-error
Package

clunit.

Source

assertion-conditions.lisp.

Direct superclasses

assertion-condition.

Direct methods
Direct slots
Slot: message

this is a special case, if an unexpected condition
is signalled outside an assertion test, store the condition description here.

Initform

(quote "")

Initargs

:message

Condition: assertion-fail-forced
Package

clunit.

Source

assertion-conditions.lisp.

Direct superclasses

assertion-condition.

Direct methods
Direct slots
Slot: format-string

the format string argument passed to format.

Initform

(quote "")

Initargs

:format-string

Slot: args

the format string arguments.

Initform

(quote "")

Initargs

:args

Condition: assertion-failed
Package

clunit.

Source

assertion-conditions.lisp.

Direct superclasses

assertion-condition.

Direct methods
Direct slots
Slot: expression

the expression that was tested.

Initform

(quote nil)

Initargs

:expression

Slot: forms

holds a list of form-value pairs, see function expand-forms for more detail.

Initform

(quote nil)

Initargs

:forms

Slot: expected

the value the expression was expected to return.

Initform

(quote nil)

Initargs

:expected

Slot: returned

the result that was returned from evaluating the expression.

Initform

(quote nil)

Initargs

:returned

Condition: assertion-passed
Package

clunit.

Source

assertion-conditions.lisp.

Direct superclasses

assertion-condition.

Condition: test-suite-failure
Package

clunit.

Source

test-suite-failure-conditions.lisp.

Direct superclasses

test-suite-failure-condition.

Direct slots
Slot: test-errors

The number of tests with errors.

Initform

(quote nil)

Initargs

:test-errors

Slot: test-failed

The number of tests that failed.

Initform

(quote nil)

Initargs

:test-fails

Slot: total-tests

The total number of tests.

Initform

(quote nil)

Initargs

:total-tests

Condition: test-suite-failure-condition
Package

clunit.

Source

test-suite-failure-conditions.lisp.

Direct superclasses

condition.

Direct subclasses

test-suite-failure.

Direct methods

print-format.


6.2.7 Classes

Class: clunit-test-case
Package

clunit.

Source

clunit-test-case.lisp.

Direct superclasses

named-class.

Direct methods
Direct slots
Slot: dependencies

The DEPENDENCIES slot holds the names of the test cases that
this test case depends on. Using an indirect reference like this allows us to easily undefine a test case without much cleaning up.

When we execute a test case and we resolve the references of the tests it depends on. If the object is not found it means the reference is now stale, so we remove the name from the list.

Initargs

:dependencies

Readers

dependencies.

Writers

(setf dependencies).

Slot: test-function

The actual test, a function with no arguments that returns non nil if the test passed

Initargs

:test-function

Readers

test-function.

Writers

(setf test-function).

Class: clunit-test-suite

The slots test-cases, child-suites and
parent-suites hold the symbol names of test cases and test suites instead of the actual objects. using an indirect reference like this allows us to undefine a test case or test suite.

When we execute a test suite and try to resolve the reference for an object. if the object is not found, it means the reference is now stale so the name of that test case or suite is removed.

Package

clunit.

Source

clunit-test-suite.lisp.

Direct superclasses

named-class.

Direct methods
Direct slots
Slot: test-cases

The tests that belongs to this suite (list of symbols)

Initargs

:test-cases

Readers

test-cases.

Writers

(setf test-cases).

Slot: child-suites
Initargs

:child-suites

Readers

child-suites.

Writers

(setf child-suites).

Class: named-class

A class for object with an identifier (the slot ’name’)

Package

clunit.

Source

clunit-test-case.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

(setf name).


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

(
(setf assertion-conditions): Private generic functions
(setf assertion-conditions): Private generic functions
(setf child-suites): Private generic functions
(setf child-suites): Private generic functions
(setf dependencies): Private generic functions
(setf dependencies): Private generic functions
(setf errors): Private generic functions
(setf errors): Private generic functions
(setf failed): Private generic functions
(setf failed): Private generic functions
(setf get-test-suite): Private ordinary functions
(setf name): Private generic functions
(setf name): Private generic functions
(setf passed): Private generic functions
(setf passed): Private generic functions
(setf skipped): Private generic functions
(setf skipped): Private generic functions
(setf skipped-tests): Private generic functions
(setf skipped-tests): Private generic functions
(setf suite-list): Private generic functions
(setf suite-list): Private generic functions
(setf test-cases): Private generic functions
(setf test-cases): Private generic functions
(setf test-function): Private generic functions
(setf test-function): Private generic functions
(setf test-report-name): Public generic functions
(setf test-report-name): Public generic functions
(setf test-report-passed): Private generic functions
(setf test-report-passed): Private generic functions
(setf test-reports): Public generic functions
(setf test-reports): Public generic functions

A
add-test-case: Private ordinary functions
all-symbols-p: Private ordinary functions
assert-condition: Public macros
assert-eq: Public macros
assert-eql: Public macros
assert-equal: Public macros
assert-equality: Public macros
assert-equality*: Public macros
assert-equalp: Public macros
assert-expands: Public macros
assert-fail: Public ordinary functions
assert-false: Public macros
assert-true: Public macros
assertion-conditions: Private generic functions
assertion-conditions: Private generic functions
assertion-expander: Private ordinary functions

C
child-suites: Private generic functions
child-suites: Private generic functions
collect-all-suite-dependencies: Private ordinary functions
collect-suite-dependencies: Private ordinary functions

D
deffixture: Public macros
defined-suite-p: Public ordinary functions
defined-test-p: Public ordinary functions
defsuite: Public macros
deftest: Public macros
deftest-declaration-dependencies: Private ordinary functions
delete-test-case: Private ordinary functions
delete-test-suite: Private ordinary functions
dependencies: Private generic functions
dependencies: Private generic functions

E
ensure-dependency-exists: Private ordinary functions
errors: Private generic functions
errors: Private generic functions
execute-test-case: Private ordinary functions
execute-test-suite: Private ordinary functions
expand-fixture: Private generic functions
expand-fixture: Private generic functions

F
failed: Private generic functions
failed: Private generic functions
form-expander: Private ordinary functions
Function, (setf get-test-suite): Private ordinary functions
Function, add-test-case: Private ordinary functions
Function, all-symbols-p: Private ordinary functions
Function, assert-fail: Public ordinary functions
Function, assertion-expander: Private ordinary functions
Function, collect-all-suite-dependencies: Private ordinary functions
Function, collect-suite-dependencies: Private ordinary functions
Function, defined-suite-p: Public ordinary functions
Function, defined-test-p: Public ordinary functions
Function, deftest-declaration-dependencies: Private ordinary functions
Function, delete-test-case: Private ordinary functions
Function, delete-test-suite: Private ordinary functions
Function, ensure-dependency-exists: Private ordinary functions
Function, execute-test-case: Private ordinary functions
Function, execute-test-suite: Private ordinary functions
Function, form-expander: Private ordinary functions
Function, get-child-suites: Public ordinary functions
Function, get-child-tests: Public ordinary functions
Function, get-defined-suites: Public ordinary functions
Function, get-defined-tests: Public ordinary functions
Function, get-test-case: Private ordinary functions
Function, get-test-suite: Private ordinary functions
Function, handle-assertion: Private ordinary functions
Function, handle-error: Private ordinary functions
Function, process-queued-tests: Private ordinary functions
Function, queue-test-case: Private ordinary functions
Function, report-assertion-progress: Private ordinary functions
Function, report-suite-progress: Private ordinary functions
Function, report-test-progress: Private ordinary functions
Function, rerun-failed-tests: Public ordinary functions
Function, run-suite: Public ordinary functions
Function, run-test: Public ordinary functions
Function, signal-assertion: Private ordinary functions
Function, skip-test-case: Private ordinary functions
Function, test-case-execution-action: Private ordinary functions

G
gen-test-form: Private macros
Generic Function, (setf assertion-conditions): Private generic functions
Generic Function, (setf child-suites): Private generic functions
Generic Function, (setf dependencies): Private generic functions
Generic Function, (setf errors): Private generic functions
Generic Function, (setf failed): Private generic functions
Generic Function, (setf name): Private generic functions
Generic Function, (setf passed): Private generic functions
Generic Function, (setf skipped): Private generic functions
Generic Function, (setf skipped-tests): Private generic functions
Generic Function, (setf suite-list): Private generic functions
Generic Function, (setf test-cases): Private generic functions
Generic Function, (setf test-function): Private generic functions
Generic Function, (setf test-report-name): Public generic functions
Generic Function, (setf test-report-passed): Private generic functions
Generic Function, (setf test-reports): Public generic functions
Generic Function, assertion-conditions: Private generic functions
Generic Function, child-suites: Private generic functions
Generic Function, dependencies: Private generic functions
Generic Function, errors: Private generic functions
Generic Function, expand-fixture: Private generic functions
Generic Function, failed: Private generic functions
Generic Function, name: Private generic functions
Generic Function, passed: Private generic functions
Generic Function, print-format: Private generic functions
Generic Function, skipped: Private generic functions
Generic Function, skipped-p: Private generic functions
Generic Function, suite-list: Private generic functions
Generic Function, test-cases: Private generic functions
Generic Function, test-function: Private generic functions
Generic Function, test-report-name: Public generic functions
Generic Function, test-report-passed-p: Public generic functions
Generic Function, test-reports: Public generic functions
get-child-suites: Public ordinary functions
get-child-tests: Public ordinary functions
get-defined-suites: Public ordinary functions
get-defined-tests: Public ordinary functions
get-test-case: Private ordinary functions
get-test-suite: Private ordinary functions

H
handle-assertion: Private ordinary functions
handle-error: Private ordinary functions

M
Macro, assert-condition: Public macros
Macro, assert-eq: Public macros
Macro, assert-eql: Public macros
Macro, assert-equal: Public macros
Macro, assert-equality: Public macros
Macro, assert-equality*: Public macros
Macro, assert-equalp: Public macros
Macro, assert-expands: Public macros
Macro, assert-false: Public macros
Macro, assert-true: Public macros
Macro, deffixture: Public macros
Macro, defsuite: Public macros
Macro, deftest: Public macros
Macro, gen-test-form: Private macros
Macro, undeffixture: Public macros
Macro, undefsuite: Public macros
Macro, undeftest: Public macros
Macro, with-assert-restart: Private macros
Macro, with-gensyms: Private macros
Macro, with-prepare-specials-for-testing: Private macros
Macro, with-test-restart: Private macros
Method, (setf assertion-conditions): Private generic functions
Method, (setf child-suites): Private generic functions
Method, (setf dependencies): Private generic functions
Method, (setf errors): Private generic functions
Method, (setf failed): Private generic functions
Method, (setf name): Private generic functions
Method, (setf passed): Private generic functions
Method, (setf skipped): Private generic functions
Method, (setf skipped-tests): Private generic functions
Method, (setf suite-list): Private generic functions
Method, (setf test-cases): Private generic functions
Method, (setf test-function): Private generic functions
Method, (setf test-report-name): Public generic functions
Method, (setf test-report-passed): Private generic functions
Method, (setf test-reports): Public generic functions
Method, assertion-conditions: Private generic functions
Method, child-suites: Private generic functions
Method, dependencies: Private generic functions
Method, errors: Private generic functions
Method, expand-fixture: Private generic functions
Method, failed: Private generic functions
Method, name: Private generic functions
Method, passed: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-format: Private generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, skipped: Private generic functions
Method, skipped-p: Private generic functions
Method, suite-list: Private generic functions
Method, test-cases: Private generic functions
Method, test-function: Private generic functions
Method, test-report-name: Public generic functions
Method, test-report-passed-p: Public generic functions
Method, test-reports: Public generic functions

N
name: Private generic functions
name: Private generic functions

P
passed: Private generic functions
passed: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-format: Private generic functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
process-queued-tests: Private ordinary functions

Q
queue-test-case: Private ordinary functions

R
report-assertion-progress: Private ordinary functions
report-suite-progress: Private ordinary functions
report-test-progress: Private ordinary functions
rerun-failed-tests: Public ordinary functions
run-suite: Public ordinary functions
run-test: Public ordinary functions

S
signal-assertion: Private ordinary functions
skip-test-case: Private ordinary functions
skipped: Private generic functions
skipped: Private generic functions
skipped-p: Private generic functions
skipped-p: Private generic functions
suite-list: Private generic functions
suite-list: Private generic functions

T
test-case-execution-action: Private ordinary functions
test-cases: Private generic functions
test-cases: Private generic functions
test-function: Private generic functions
test-function: Private generic functions
test-report-name: Public generic functions
test-report-name: Public generic functions
test-report-passed-p: Public generic functions
test-report-passed-p: Public generic functions
test-reports: Public generic functions
test-reports: Public generic functions

U
undeffixture: Public macros
undefsuite: Public macros
undeftest: Public macros

W
with-assert-restart: Private macros
with-gensyms: Private macros
with-prepare-specials-for-testing: Private macros
with-test-restart: Private macros


A.3 Variables

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

*
*clunit-equality-test*: Public special variables
*clunit-report*: Private special variables
*clunit-report-format*: Public special variables
*clunit-test-report*: Private special variables
*last-clunit-report*: Private special variables
*queued-test-reports*: Private special variables
*report-progress*: Private special variables
*stop-on-fail*: Private special variables
*suite-name*: Private special variables
*tab-width*: Private special variables
*tap-test-num*: Private special variables
*test-case-hashtable*: Private special variables
*test-name*: Private special variables
*test-output-stream*: Public special variables
*test-suite-alist*: Private special variables
*test-suite-hashtable*: Private special variables
*use-debugger*: Private special variables

+
+assertion-conditions-reserved-size+: Private constants

A
args: Private conditions
assertion-conditions: Public classes

C
child-suites: Private classes
Constant, +assertion-conditions-reserved-size+: Private constants

D
dependencies: Private classes

E
errors: Public classes
expected: Private conditions
expression: Private conditions

F
failed: Public classes
format-string: Private conditions
forms: Private conditions

M
message: Private conditions

N
name: Private classes

P
passed: Public classes
passed-p: Public classes

R
returned: Private conditions

S
skipped: Public classes
skipped-p: Public classes
Slot, args: Private conditions
Slot, assertion-conditions: Public classes
Slot, child-suites: Private classes
Slot, dependencies: Private classes
Slot, errors: Public classes
Slot, expected: Private conditions
Slot, expression: Private conditions
Slot, failed: Public classes
Slot, format-string: Private conditions
Slot, forms: Private conditions
Slot, message: Private conditions
Slot, name: Private classes
Slot, passed: Public classes
Slot, passed-p: Public classes
Slot, returned: Private conditions
Slot, skipped: Public classes
Slot, skipped-p: Public classes
Slot, suite-list: Public classes
Slot, test-cases: Private classes
Slot, test-errors: Private conditions
Slot, test-failed: Private conditions
Slot, test-function: Private classes
Slot, test-name: Public classes
Slot, test-reports: Public classes
Slot, total-tests: Private conditions
Special Variable, *clunit-equality-test*: Public special variables
Special Variable, *clunit-report*: Private special variables
Special Variable, *clunit-report-format*: Public special variables
Special Variable, *clunit-test-report*: Private special variables
Special Variable, *last-clunit-report*: Private special variables
Special Variable, *queued-test-reports*: Private special variables
Special Variable, *report-progress*: Private special variables
Special Variable, *stop-on-fail*: Private special variables
Special Variable, *suite-name*: Private special variables
Special Variable, *tab-width*: Private special variables
Special Variable, *tap-test-num*: Private special variables
Special Variable, *test-case-hashtable*: Private special variables
Special Variable, *test-name*: Private special variables
Special Variable, *test-output-stream*: Public special variables
Special Variable, *test-suite-alist*: Private special variables
Special Variable, *test-suite-hashtable*: Private special variables
Special Variable, *use-debugger*: Private special variables
suite-list: Public classes

T
test-cases: Private classes
test-errors: Private conditions
test-failed: Private conditions
test-function: Private classes
test-name: Public classes
test-reports: Public classes
total-tests: Private conditions


A.4 Data types

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

A
assertion-condition: Private conditions
assertion-conditions.lisp: The clunit2/src/classes/assertion-conditions․lisp file
assertion-error: Private conditions
assertion-fail-forced: Private conditions
assertion-failed: Private conditions
assertion-functions.lisp: The clunit2/src/functions/assertion-functions․lisp file
assertion-macros.lisp: The clunit2/src/macros/assertion-macros․lisp file
assertion-passed: Private conditions

C
Class, clunit-report: Public classes
Class, clunit-test-case: Private classes
Class, clunit-test-report: Public classes
Class, clunit-test-suite: Private classes
Class, named-class: Private classes
classes: The clunit2/src/classes module
clunit: The clunit package
clunit-report: Public classes
clunit-report.lisp: The clunit2/src/classes/clunit-report․lisp file
clunit-test-case: Private classes
clunit-test-case.lisp: The clunit2/src/classes/clunit-test-case․lisp file
clunit-test-report: Public classes
clunit-test-report.lisp: The clunit2/src/classes/clunit-test-report․lisp file
clunit-test-suite: Private classes
clunit-test-suite.lisp: The clunit2/src/classes/clunit-test-suite․lisp file
clunit2: The clunit2 system
clunit2.asd: The clunit2/clunit2․asd file
Condition, assertion-condition: Private conditions
Condition, assertion-error: Private conditions
Condition, assertion-fail-forced: Private conditions
Condition, assertion-failed: Private conditions
Condition, assertion-passed: Private conditions
Condition, test-suite-failure: Private conditions
Condition, test-suite-failure-condition: Private conditions

D
deffixture.lisp: The clunit2/src/macros/deffixture․lisp file
defsuite.lisp: The clunit2/src/macros/defsuite․lisp file
deftest.lisp: The clunit2/src/macros/deftest․lisp file

F
File, assertion-conditions.lisp: The clunit2/src/classes/assertion-conditions․lisp file
File, assertion-functions.lisp: The clunit2/src/functions/assertion-functions․lisp file
File, assertion-macros.lisp: The clunit2/src/macros/assertion-macros․lisp file
File, clunit-report.lisp: The clunit2/src/classes/clunit-report․lisp file
File, clunit-test-case.lisp: The clunit2/src/classes/clunit-test-case․lisp file
File, clunit-test-report.lisp: The clunit2/src/classes/clunit-test-report․lisp file
File, clunit-test-suite.lisp: The clunit2/src/classes/clunit-test-suite․lisp file
File, clunit2.asd: The clunit2/clunit2․asd file
File, deffixture.lisp: The clunit2/src/macros/deffixture․lisp file
File, defsuite.lisp: The clunit2/src/macros/defsuite․lisp file
File, deftest.lisp: The clunit2/src/macros/deftest․lisp file
File, generic-functions.lisp: The clunit2/src/functions/generic-functions․lisp file
File, package.lisp: The clunit2/src/package․lisp file
File, prepare-specials.lisp: The clunit2/src/functions/prepare-specials․lisp file
File, print-object.lisp: The clunit2/src/report-formats/print-object․lisp file
File, progress-report-functions.lisp: The clunit2/src/functions/progress-report-functions․lisp file
File, report-format-default.lisp: The clunit2/src/report-formats/report-format-default․lisp file
File, report-format-tap.lisp: The clunit2/src/report-formats/report-format-tap․lisp file
File, rerun-failed-tests.lisp: The clunit2/src/functions/rerun-failed-tests․lisp file
File, specials.lisp: The clunit2/src/specials․lisp file
File, test-case-functions.lisp: The clunit2/src/functions/test-case-functions․lisp file
File, test-suite-failure-conditions.lisp: The clunit2/src/classes/test-suite-failure-conditions․lisp file
File, test-suite-functions.lisp: The clunit2/src/functions/test-suite-functions․lisp file
File, utilities.lisp: The clunit2/src/functions/utilities․lisp file
File, utility-macros.lisp: The clunit2/src/macros/utility-macros․lisp file
functions: The clunit2/src/functions module

G
generic-functions.lisp: The clunit2/src/functions/generic-functions․lisp file

M
macros: The clunit2/src/macros module
Module, classes: The clunit2/src/classes module
Module, functions: The clunit2/src/functions module
Module, macros: The clunit2/src/macros module
Module, report-formats: The clunit2/src/report-formats module
Module, src: The clunit2/src module

N
named-class: Private classes

P
Package, clunit: The clunit package
package.lisp: The clunit2/src/package․lisp file
prepare-specials.lisp: The clunit2/src/functions/prepare-specials․lisp file
print-object.lisp: The clunit2/src/report-formats/print-object․lisp file
progress-report-functions.lisp: The clunit2/src/functions/progress-report-functions․lisp file

R
report-format-default.lisp: The clunit2/src/report-formats/report-format-default․lisp file
report-format-tap.lisp: The clunit2/src/report-formats/report-format-tap․lisp file
report-formats: The clunit2/src/report-formats module
rerun-failed-tests.lisp: The clunit2/src/functions/rerun-failed-tests․lisp file

S
specials.lisp: The clunit2/src/specials․lisp file
src: The clunit2/src module
System, clunit2: The clunit2 system

T
test-case-functions.lisp: The clunit2/src/functions/test-case-functions․lisp file
test-suite-failure: Private conditions
test-suite-failure-condition: Private conditions
test-suite-failure-conditions.lisp: The clunit2/src/classes/test-suite-failure-conditions․lisp file
test-suite-functions.lisp: The clunit2/src/functions/test-suite-functions․lisp file

U
utilities.lisp: The clunit2/src/functions/utilities․lisp file
utility-macros.lisp: The clunit2/src/macros/utility-macros․lisp file