The clunit2 Reference Manual

Table of Contents

The clunit2 Reference Manual

This is the clunit2 Reference Manual, version 0.3.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Dec 22 13:06:26 2020 GMT+0.

1 Introduction

* CLUnit

* Overview

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

- Author: Tapiwa Gutu
- Maintainer of this fork: cage

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
  [[http://en.wikipedia.org/wiki/Test_Anything_Protocol]["Test Anything Protocol" (TAP)]] output.
+ Released under MIT license

Check out the comprehensive [[http://tgutu.github.com/clunit][CLUnit Tutorial]].

* Example

#+BEGIN_SRC lisp
  (ql:quickload "clunit")

  (use-package :clunit)

  ;; Test suite for all number operation tests.
  (defsuite number-suite ())

  ;; Test suite for floating point operations
  (defsuite float-suite (number-suite))

  (defsuite integer-suite (number-suite))

  ;; Define a test called TEST-INT1
  (deftest test-int-1 (integer-suite)
    (assert-true  (= 1 1))
    (assert-equalp 4 (+ 2 2)))

  ;; Define a test called TEST-FLOAT1
  (deftest test-float-1 (float-suite)
    (assert-true (= 1.0 -1.0))
    (assert-equalp 4.0 (+ 2.0 2.0)))

  (run-suite 'number-suite)

#+END_SRC

which produces the output:

#+BEGIN_SRC
PROGRESS:
=========

    NUMBER-SUITE: (Test Suite)

        INTEGER-SUITE: (Test Suite)
            TEST-INT-1: ..

        FLOAT-SUITE: (Test Suite)
            TEST-FLOAT-1: F.

FAILURE DETAILS:
================

    NUMBER-SUITE -> FLOAT-SUITE: (Test Suite)
        TEST-FLOAT-1: Expression: (= 1.0 -1.0)
                      Expected: T
                      Returned: NIL


SUMMARY:
========
    Test functions:
        Executed: 2
        Skipped:  0

    Tested 4 assertions.
        Passed: 3/4 some tests not passed
        Failed: 1/4 some tests failed
#+END_SRC

* Tests and assertions

Each  test, like  ~test-int1~ in  the above  example, can  contain a
number of assertions, given in the table below:

|-----------------------------------------+------------------------------------------------------------------------------------------------------------------------------|
| Assertion                               | Description                                                                                                                  |
|-----------------------------------------+------------------------------------------------------------------------------------------------------------------------------|
|                                         | <20>                                                                                                                         |
| ~assert-true EXPRESSION~                | Passes if the expression ~EXPRESSION~ is not ~NIL~                                                                           |
| ~assert-false EXPRESSION~               | Passes if ~EXPRESSION~ is ~NIL~                                                                                              |
| ~assert-eq VALUE EXPRESSION~            | Passes if ~(EQ VALUE EXPRESSION)~ returns true                                                                               |
| ~assert-eql VALUE EXPRESSION~           | Passes if ~(EQL VALUE EXPRESSION)~ returns true                                                                              |
| ~assert-equal VALUE EXPRESSION~         | Passes if ~(EQUAL VALUE EXPRESSION)~ returns true                                                                            |
| ~assert-equalp VALUE EXPRESSION~        | Passes if ~(EQUALP VALUE EXPRESSION)~ returns true                                                                           |
| ~assert-equality TEST VALUE EXPRESSION~ | Passes if ~(FUNCALL TEST VALUE EXPRESSION)~ returns true                                                                     |
| ~assert-equality* VALUE EXPRESSION~     | Passes if  ~(FUNCALL *clunit-equality-test* VALUE EXPRESSION)~ returns true. By default *clunit-equality-test* is ~EQUALP~ |
| ~assert-expands EXPANSION EXPRESSION~   | Tests macro expansion, passes if ~(EQUALP EXPANSION (MACROEXPAND-1 EXPRESSION))~ is true                                     |
| ~assert-condition CONDITION EXPRESSION~ | Passes if ~EXPRESSION~ signals ~CONDITION~                                                                                   |
| ~assert-fails FORMAT-STRING~            | Force test to fail, giving a format string for the message                                                                   |
|-----------------------------------------+------------------------------------------------------------------------------------------------------------------------------|

All  of these  tests  take  optional forms,  which  are evaluated  and
printed  if  the test  fails.   These  can  be  used to  provide  test
diagnostics or documentation. For example

#+BEGIN_SRC lisp
  (deftest test-suiteless ()
    (let ((a 1) (b 2) (c 3))
      (assert-true (= a b c) "This assertion is meant to fail." a b c )))

  (run-test 'test-suiteless :report-progress nil)
#+END_SRC

produces the output:

#+BEGIN_SRC
FAILURE DETAILS:
================
    TEST-SUITELESS: Expression: (= A B C)
                    Expected: T
                    Returned: NIL
                    This assertion is meant to fail.
                    A => 1
                    B => 2
                    C => 3


SUMMARY:
========
    Test functions:
        Executed: 1
        Skipped:  0

    Tested 1 assertion.
        Failed: 1/1 all tests failed
#+END_SRC

* BUGS
  Please file bug report on
  the [[https://notabug.org/cage/clunit2/issues][issue tracker]]

* Notes

This  is a  fork of https://github.com/tgutu/clunit .

2 Systems

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

2.1 clunit2

Maintainer

cage

Author

Tapiwa Gutu

Bug Tracker

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

License

BSD

Description

CLUnit is a Common Lisp unit testing framework.

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.3.0

Source

clunit2.asd (file)

Component

src (module)

3 Modules

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

3.1 clunit2/src

Parent

clunit2 (system)

Location

src/

Components

• package.lisp (file)
• specials.lisp (file)
• classes (module)
• functions (module)
• report-formats (module)
• macros (module)

3.2 clunit2/src/classes

Dependency

specials.lisp (file)

Parent

src (module)

Location

src/classes/

Components

• assertion-conditions.lisp (file)
• test-suite-failure-conditions.lisp (file)
• clunit-report.lisp (file)
• clunit-test-case.lisp (file)
• clunit-test-suite.lisp (file)
• clunit-test-report.lisp (file)

3.3 clunit2/src/functions

Dependency

classes (module)

Parent

src (module)

Location

src/functions/

Components

• prepare-specials.lisp (file)
• assertion-functions.lisp (file)
• generic-functions.lisp (file)
• test-case-functions.lisp (file)
• test-suite-functions.lisp (file)
• rerun-failed-tests.lisp (file)
• progress-report-functions.lisp (file)

3.4 clunit2/src/report-formats

Dependency

functions (module)

Parent

src (module)

Location

src/report-formats/

Components

• report-format-default.lisp (file)
• report-format-tap.lisp (file)
• print-object.lisp (file)

3.5 clunit2/src/macros

Dependency

report-formats (module)

Parent

src (module)

Location

src/macros/

Components

• utility-macros.lisp (file)
• assertion-macros.lisp (file)
• deffixture.lisp (file)
• defsuite.lisp (file)
• deftest.lisp (file)

4 Files

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

4.1 Lisp

4.1.1 clunit2.asd

Location

clunit2.asd

Systems

clunit2 (system)

4.1.2 clunit2/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

clunit

4.1.3 clunit2/src/specials.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/specials.lisp

Exported Definitions

• *clunit-equality-test* (special variable)
• *clunit-report-format* (special variable)
• *test-output-stream* (special variable)

Internal Definitions

• *clunit-report* (special variable)
• *clunit-test-report* (special variable)
• *last-clunit-report* (special variable)
• *queued-test-reports* (special variable)
• *report-progress* (special variable)
• *stop-on-fail* (special variable)
• *suite-name* (special variable)
• *tab-width* (special variable)
• *test-case-hashtable* (special variable)
• *test-name* (special variable)
• *test-suite-hashtable* (special variable)
• *use-debugger* (special variable)

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

Parent

classes (module)

Location

src/classes/assertion-conditions.lisp

Internal Definitions

• assertion-condition (condition)
• assertion-error (condition)
• assertion-fail-forced (condition)
• assertion-failed (condition)
• assertion-passed (condition)

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

Parent

classes (module)

Location

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

Internal Definitions

• test-suite-failure (condition)
• test-suite-failure-condition (condition)

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

Parent

classes (module)

Location

src/classes/clunit-report.lisp

Exported Definitions

• clunit-report (class)
• test-reports (method)
• (setf test-reports) (method)

Internal Definitions

• errors (method)
• (setf errors) (method)
• failed (method)
• (setf failed) (method)
• passed (method)
• (setf passed) (method)
• skipped (method)
• (setf skipped) (method)

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

Parent

classes (module)

Location

src/classes/clunit-test-case.lisp

Internal Definitions

• clunit-test-case (class)
• dependencies (method)
• (setf dependencies) (method)
• name (method)
• (setf name) (method)
• named-class (class)
• test-function (method)
• (setf test-function) (method)

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

Parent

classes (module)

Location

src/classes/clunit-test-suite.lisp

Internal Definitions

• child-suites (method)
• (setf child-suites) (method)
• clunit-test-suite (class)
• test-cases (method)
• (setf test-cases) (method)

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

Parent

classes (module)

Location

src/classes/clunit-test-report.lisp

Exported Definitions

• clunit-test-report (class)
• test-report-name (method)
• (setf test-report-name) (method)
• test-report-passed-p (method)

Internal Definitions

• assertion-conditions (method)
• (setf assertion-conditions) (method)
• skipped-p (method)
• (setf skipped-tests) (method)
• suite-list (method)
• (setf suite-list) (method)
• (setf test-report-passed) (method)

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

Parent

functions (module)

Location

src/functions/prepare-specials.lisp

Internal Definitions

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

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

Parent

functions (module)

Location

src/functions/assertion-functions.lisp

Internal Definitions

• handle-assertion (function)
• handle-error (function)
• signal-assertion (function)

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

Parent

functions (module)

Location

src/functions/generic-functions.lisp

Internal Definitions

• expand-fixture (generic function)
• expand-fixture (method)
• print-format (generic function)

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

Parent

functions (module)

Location

src/functions/test-case-functions.lisp

Exported Definitions

• defined-test-p (function)
• get-defined-tests (function)
• run-test (function)

Internal Definitions

• delete-test-case (function)
• execute-test-case (function)
• get-test-case (function)
• (setf get-test-case) (function)
• process-queued-tests (function)
• queue-test-case (function)
• skip-test-case (function)
• test-case-execution-action (function)

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

Parent

functions (module)

Location

src/functions/test-suite-functions.lisp

Exported Definitions

• defined-suite-p (function)
• get-child-suites (function)
• get-child-tests (function)
• get-defined-suites (function)
• run-suite (function)

Internal Definitions

• delete-test-suite (function)
• execute-test-suite (function)
• get-test-suite (function)
• (setf get-test-suite) (function)

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

Parent

functions (module)

Location

src/functions/rerun-failed-tests.lisp

Exported Definitions

rerun-failed-tests (function)

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

Parent

functions (module)

Location

src/functions/progress-report-functions.lisp

Internal Definitions

• report-assertion-progress (function)
• report-suite-progress (function)
• report-test-progress (function)

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

Parent

report-formats (module)

Location

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

Internal Definitions

• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)

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

Parent

report-formats (module)

Location

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

Internal Definitions

• *tap-test-num* (special variable)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)

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

Parent

report-formats (module)

Location

src/report-formats/print-object.lisp

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

Parent

macros (module)

Location

src/macros/utility-macros.lisp

Internal Definitions

• with-assert-restart (macro)
• with-gensyms (macro)
• with-test-restart (macro)

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

Dependency

utility-macros.lisp (file)

Parent

macros (module)

Location

src/macros/assertion-macros.lisp

Exported Definitions

• assert-condition (macro)
• assert-eq (macro)
• assert-eql (macro)
• assert-equal (macro)
• assert-equality (macro)
• assert-equality* (macro)
• assert-equalp (macro)
• assert-expands (macro)
• assert-fail (function)
• assert-false (macro)
• assert-true (macro)

Internal Definitions

• assertion-expander (function)
• form-expander (function)

4.1.22 clunit2/src/macros/deffixture.lisp

Dependency

assertion-macros.lisp (file)

Parent

macros (module)

Location

src/macros/deffixture.lisp

Exported Definitions

• deffixture (macro)
• undeffixture (macro)

4.1.23 clunit2/src/macros/defsuite.lisp

Dependency

deffixture.lisp (file)

Parent

macros (module)

Location

src/macros/defsuite.lisp

Exported Definitions

• defsuite (macro)
• undefsuite (macro)

4.1.24 clunit2/src/macros/deftest.lisp

Dependency

defsuite.lisp (file)

Parent

macros (module)

Location

src/macros/deftest.lisp

Exported Definitions

• deftest (macro)
• undeftest (macro)

5 Packages

Packages are listed by definition order.

5.1 clunit

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions

• *clunit-equality-test* (special variable)
• *clunit-report-format* (special variable)
• *test-output-stream* (special variable)
• assert-condition (macro)
• assert-eq (macro)
• assert-eql (macro)
• assert-equal (macro)
• assert-equality (macro)
• assert-equality* (macro)
• assert-equalp (macro)
• assert-expands (macro)
• assert-fail (function)
• assert-false (macro)
• assert-true (macro)
• clunit-report (class)
• clunit-test-report (class)
• deffixture (macro)
• defined-suite-p (function)
• defined-test-p (function)
• defsuite (macro)
• deftest (macro)
• get-child-suites (function)
• get-child-tests (function)
• get-defined-suites (function)
• get-defined-tests (function)
• rerun-failed-tests (function)
• run-suite (function)
• run-test (function)
• test-report-name (generic function)
• test-report-name (method)
• (setf test-report-name) (method)
• (setf test-report-name) (generic function)
• test-report-passed-p (generic function)
• test-report-passed-p (method)
• test-reports (generic function)
• test-reports (method)
• (setf test-reports) (method)
• (setf test-reports) (generic function)
• undeffixture (macro)
• undefsuite (macro)
• undeftest (macro)

Internal Definitions

• *clunit-report* (special variable)
• *clunit-test-report* (special variable)
• *last-clunit-report* (special variable)
• *queued-test-reports* (special variable)
• *report-progress* (special variable)
• *stop-on-fail* (special variable)
• *suite-name* (special variable)
• *tab-width* (special variable)
• *tap-test-num* (special variable)
• *test-case-hashtable* (special variable)
• *test-name* (special variable)
• *test-suite-hashtable* (special variable)
• *use-debugger* (special variable)
• assertion-condition (condition)
• assertion-conditions (generic function)
• assertion-conditions (method)
• (setf assertion-conditions) (method)
• (setf assertion-conditions) (generic function)
• assertion-error (condition)
• assertion-expander (function)
• assertion-fail-forced (condition)
• assertion-failed (condition)
• assertion-passed (condition)
• child-suites (generic function)
• child-suites (method)
• (setf child-suites) (method)
• (setf child-suites) (generic function)
• clunit-test-case (class)
• clunit-test-suite (class)
• delete-test-case (function)
• delete-test-suite (function)
• dependencies (generic function)
• dependencies (method)
• (setf dependencies) (method)
• (setf dependencies) (generic function)
• errors (generic function)
• errors (method)
• (setf errors) (method)
• (setf errors) (generic function)
• execute-test-case (function)
• execute-test-suite (function)
• expand-fixture (generic function)
• expand-fixture (method)
• failed (generic function)
• failed (method)
• (setf failed) (method)
• (setf failed) (generic function)
• form-expander (function)
• get-test-case (function)
• (setf get-test-case) (function)
• get-test-suite (function)
• (setf get-test-suite) (function)
• handle-assertion (function)
• handle-error (function)
• name (generic function)
• name (method)
• (setf name) (method)
• (setf name) (generic function)
• named-class (class)
• passed (generic function)
• passed (method)
• (setf passed) (method)
• (setf passed) (generic function)
• print-format (generic function)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• print-format (method)
• process-queued-tests (function)
• queue-test-case (function)
• report-assertion-progress (function)
• report-suite-progress (function)
• report-test-progress (function)
• signal-assertion (function)
• skip-test-case (function)
• skipped (generic function)
• skipped (method)
• (setf skipped) (method)
• (setf skipped) (generic function)
• skipped-p (generic function)
• skipped-p (method)
• (setf skipped-tests) (generic function)
• (setf skipped-tests) (method)
• suite-list (generic function)
• suite-list (method)
• (setf suite-list) (method)
• (setf suite-list) (generic function)
• test-case-execution-action (function)
• test-cases (generic function)
• test-cases (method)
• (setf test-cases) (method)
• (setf test-cases) (generic function)
• test-function (generic function)
• test-function (method)
• (setf test-function) (method)
• (setf test-function) (generic function)
• (setf test-report-passed) (generic function)
• (setf test-report-passed) (method)
• test-suite-failure (condition)
• test-suite-failure-condition (condition)
• with-assert-restart (macro)
• with-gensyms (macro)
• with-prepare-specials-for-testing (macro)
• with-test-restart (macro)

6 Definitions

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

6.1 Exported definitions

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 (file)

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 (file)

Special Variable: *test-output-stream*

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

Package

clunit

Source

specials.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 runtime, so the fixture that will wrap around a test depends on the test suite call stack.

Example:

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

Package

clunit

Source

deffixture.lisp (file)

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 (file)

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 (file)

Macro: undeffixture NAME

Remove a fixture definition.

Package

clunit

Source

deffixture.lisp (file)

Macro: undefsuite NAME

Package

clunit

Source

defsuite.lisp (file)

Macro: undeftest NAME

Package

clunit

Source

deftest.lisp (file)

6.1.3 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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: get-defined-suites ()

Returns a list of all defined test suite names.

Package

clunit

Source

test-suite-functions.lisp (file)

Function: get-defined-tests ()

Returns a list of all defined test case names.

Package

clunit

Source

test-case-functions.lisp (file)

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 (file)

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 (file)

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 (file)

6.1.4 Generic functions

Generic Function: test-report-name OBJECT

Generic Function: (setf test-report-name) NEW-VALUE OBJECT

Package

clunit

Methods

Method: test-report-name (CLUNIT-TEST-REPORT clunit-test-report)

Method: (setf test-report-name) NEW-VALUE (CLUNIT-TEST-REPORT clunit-test-report)

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

Source

clunit-test-report.lisp (file)

Generic Function: test-report-passed-p OBJECT

Package

clunit

Methods

Method: test-report-passed-p (CLUNIT-TEST-REPORT clunit-test-report)

Non-nil if the report passed

Source

clunit-test-report.lisp (file)

Generic Function: test-reports OBJECT

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

Package

clunit

Methods

Method: test-reports (CLUNIT-REPORT clunit-report)

Method: (setf test-reports) NEW-VALUE (CLUNIT-REPORT clunit-report)

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

Source

clunit-report.lisp (file)

6.1.5 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 (file)

Direct superclasses

standard-object (class)

Direct methods

• print-object (method)
• print-format (method)
• print-format (method)
• test-reports (method)
• test-reports (method)
• skipped (method)
• skipped (method)
• passed (method)
• passed (method)
• failed (method)
• failed (method)
• errors (method)
• errors (method)

Direct slots

Slot: errors

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

Initargs

:errors

Initform

0

Readers

errors (generic function)

Writers

(setf errors) (generic function)

Slot: failed

The number of tests failed during test executions.

Initargs

:failed

Initform

0

Readers

failed (generic function)

Writers

(setf failed) (generic function)

Slot: passed

The number of tests that passed during test executions.

Initargs

:passed

Initform

0

Readers

passed (generic function)

Writers

(setf passed) (generic function)

Slot: skipped

The number of tests that was skipped during test executions.

Initargs

:skipped

Initform

0

Readers

skipped (generic function)

Writers

(setf skipped) (generic function)

Slot: test-reports

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

Readers

test-reports (generic function)

Writers

(setf test-reports) (generic function)

Class: clunit-test-report ()

Package

clunit

Source

clunit-test-report.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• print-object (method)
• print-format (method)
• print-format (method)
• assertion-conditions (method)
• assertion-conditions (method)
• suite-list (method)
• suite-list (method)
• (setf skipped-tests) (method)
• skipped-p (method)
• (setf test-report-passed) (method)
• test-report-passed-p (method)
• test-report-name (method)
• test-report-name (method)

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 (generic function)

Writers

(setf test-report-name) (generic function)

Slot: passed-p

Non-nil if the report passed

Initargs

:passed-p

Initform

t

Readers

test-report-passed-p (generic function)

Writers

(setf test-report-passed) (generic function)

Slot: skipped-p

Non-nil if the test was skipped

Initargs

:skipped-p

Readers

skipped-p (generic function)

Writers

(setf skipped-tests) (generic function)

Slot: suite-list

A list of the suites this test belong.

Initargs

:suite-list

Readers

suite-list (generic function)

Writers

(setf suite-list) (generic function)

Slot: assertion-conditions

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

Readers

assertion-conditions (generic function)

Writers

(setf assertion-conditions) (generic function)

6.2 Internal definitions

6.2.1 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 (file)

Special Variable: *clunit-test-report*

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

Package

clunit

Source

specials.lisp (file)

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 (file)

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 (file)

Special Variable: *report-progress*

This variable switches on progress reporting if set to true.

Package

clunit

Source

specials.lisp (file)

Special Variable: *stop-on-fail*

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

Package

clunit

Source

specials.lisp (file)

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 (file)

Special Variable: *tab-width*

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

Package

clunit

Source

specials.lisp (file)

Special Variable: *tap-test-num*

Counter used in these printing functions

Package

clunit

Source

report-format-tap.lisp (file)

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 (file)

Special Variable: *test-name*

Holds the name of the test currently executing.

Package

clunit

Source

specials.lisp (file)

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 (file)

Special Variable: *use-debugger*

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

Package

clunit

Source

specials.lisp (file)

6.2.2 Macros

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 (file)

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 (file)

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 (file)

Macro: with-test-restart &body BODY

Package

clunit

Source

utility-macros.lisp (file)

6.2.3 Functions

Function: assertion-expander &key RESULT TEST RESULT-EXPRESSION REPORT-EXPRESSION EXPECTED FORMS

Expands an assertion macro call.

Package

clunit

Source

assertion-macros.lisp (file)

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 (file)

Function: delete-test-suite NAME

Deletes the TEST-SUITE instance associated with the key NAME in the hash table *TEST-SUITES*

Package

clunit

Source

test-suite-functions.lisp (file)

Function: execute-test-case TEST-CASE

Package

clunit

Source

test-case-functions.lisp (file)

Function: execute-test-suite TEST-SUITE

Package

clunit

Source

test-suite-functions.lisp (file)

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 (file)

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 (file)

Writer

(setf get-test-case) (function)

Function: (setf get-test-case) NEW-TEST-CASE NAME

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

Package

clunit

Source

test-case-functions.lisp (file)

Reader

get-test-case (function)

Function: get-test-suite NAME

Retrieves the TEST-SUITE instance associated with the key NAME in the hash table *TEST-SUITES*

Package

clunit

Source

test-suite-functions.lisp (file)

Writer

(setf get-test-suite) (function)

Function: (setf get-test-suite) NEW-TEST-SUITE NAME

Adds NEW-TEST-SUITE in the hash table *TEST-SUITES* under the key NAME.

Package

clunit

Source

test-suite-functions.lisp (file)

Reader

get-test-suite (function)

Function: handle-assertion CONDITION

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

Package

clunit

Source

assertion-functions.lisp (file)

Function: handle-error ERROR

Package

clunit

Source

assertion-functions.lisp (file)

Function: process-queued-tests ()

Package

clunit

Source

test-case-functions.lisp (file)

Function: queue-test-case ()

Enqueue a test.

Package

clunit

Source

test-case-functions.lisp (file)

Function: report-assertion-progress TYPE

Package

clunit

Source

progress-report-functions.lisp (file)

Function: report-suite-progress SUITE SUITE-LIST

Package

clunit

Source

progress-report-functions.lisp (file)

Function: report-test-progress TEST-NAME SUITE-LIST

Package

clunit

Source

progress-report-functions.lisp (file)

Function: signal-assertion TYPE &key EXPRESSION EXPECTED RETURNED FORMS MESSAGE FORMAT-STRING ARGS

Package

clunit

Source

assertion-functions.lisp (file)

Function: skip-test-case ()

Skip a test.

Package

clunit

Source

test-case-functions.lisp (file)

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 (file)

6.2.4 Generic functions

Generic Function: assertion-conditions OBJECT

Generic Function: (setf assertion-conditions) NEW-VALUE OBJECT

Package

clunit

Methods

Method: assertion-conditions (CLUNIT-TEST-REPORT clunit-test-report)

Method: (setf assertion-conditions) NEW-VALUE (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 (file)

Generic Function: child-suites OBJECT

Generic Function: (setf child-suites) NEW-VALUE OBJECT

Package

clunit

Methods

Method: child-suites (CLUNIT-TEST-SUITE clunit-test-suite)

automatically generated reader method

Source

clunit-test-suite.lisp (file)

Method: (setf child-suites) NEW-VALUE (CLUNIT-TEST-SUITE clunit-test-suite)

automatically generated writer method

Source

clunit-test-suite.lisp (file)

Generic Function: dependencies OBJECT

Generic Function: (setf dependencies) NEW-VALUE OBJECT

Package

clunit

Methods

Method: dependencies (CLUNIT-TEST-CASE clunit-test-case)

Method: (setf dependencies) NEW-VALUE (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 (file)

Generic Function: errors OBJECT

Generic Function: (setf errors) NEW-VALUE OBJECT

Package

clunit

Methods

Method: errors (CLUNIT-REPORT clunit-report)

Method: (setf errors) NEW-VALUE (CLUNIT-REPORT clunit-report)

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

Source

clunit-report.lisp (file)

Generic Function: expand-fixture SUITE BODY

Expands out a fixture body for the given test suite.

Package

clunit

Source

generic-functions.lisp (file)

Methods

Method: expand-fixture SUITE BODY

Generic Function: failed OBJECT

Generic Function: (setf failed) NEW-VALUE OBJECT

Package

clunit

Methods

Method: failed (CLUNIT-REPORT clunit-report)

Method: (setf failed) NEW-VALUE (CLUNIT-REPORT clunit-report)

The number of tests failed during test executions.

Source

clunit-report.lisp (file)

Generic Function: name OBJECT

Generic Function: (setf name) NEW-VALUE OBJECT

Package

clunit

Methods

Method: name (NAMED-CLASS named-class)

automatically generated reader method

Source

clunit-test-case.lisp (file)

Method: (setf name) NEW-VALUE (NAMED-CLASS named-class)

automatically generated writer method

Source

clunit-test-case.lisp (file)

Generic Function: passed OBJECT

Generic Function: (setf passed) NEW-VALUE OBJECT

Package

clunit

Methods

Method: passed (CLUNIT-REPORT clunit-report)

Method: (setf passed) NEW-VALUE (CLUNIT-REPORT clunit-report)

The number of tests that passed during test executions.

Source

clunit-report.lisp (file)

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 (file)

Methods

Method: print-format (CONDITION assertion-fail-forced) (FORMAT (eql tap)) STREAM

Source

report-format-tap.lisp (file)

Method: print-format (CONDITION assertion-failed) (FORMAT (eql tap)) STREAM

Source

report-format-tap.lisp (file)

Method: print-format (CONDITION assertion-error) (FORMAT (eql tap)) STREAM

Source

report-format-tap.lisp (file)

Method: print-format (REPORT clunit-test-report) (FORMAT (eql tap)) STREAM

Source

report-format-tap.lisp (file)

Method: print-format (CLUNIT-REPORT clunit-report) (FORMAT (eql tap)) STREAM

Source

report-format-tap.lisp (file)

Method: print-format (CONDITION test-suite-failure-condition) (FORMAT (eql default)) STREAM

Source

report-format-default.lisp (file)

Method: print-format (CONDITION assertion-fail-forced) (FORMAT (eql default)) STREAM

Source

report-format-default.lisp (file)

Method: print-format (CONDITION assertion-failed) (FORMAT (eql default)) STREAM

Source

report-format-default.lisp (file)

Method: print-format (CONDITION assertion-error) (FORMAT (eql default)) STREAM

Source

report-format-default.lisp (file)

Method: print-format (REPORT clunit-test-report) (FORMAT (eql default)) STREAM

Source

report-format-default.lisp (file)

Method: print-format (CLUNIT-REPORT clunit-report) (FORMAT (eql default)) STREAM

Source

report-format-default.lisp (file)

Generic Function: skipped OBJECT

Generic Function: (setf skipped) NEW-VALUE OBJECT

Package

clunit

Methods

Method: skipped (CLUNIT-REPORT clunit-report)

Method: (setf skipped) NEW-VALUE (CLUNIT-REPORT clunit-report)

The number of tests that was skipped during test executions.

Source

clunit-report.lisp (file)

Generic Function: skipped-p OBJECT

Package

clunit

Methods

Method: skipped-p (CLUNIT-TEST-REPORT clunit-test-report)

Non-nil if the test was skipped

Source

clunit-test-report.lisp (file)

Generic Function: (setf skipped-tests) NEW-VALUE OBJECT

Package

clunit

Methods

Method: (setf skipped-tests) NEW-VALUE (CLUNIT-TEST-REPORT clunit-test-report)

Non-nil if the test was skipped

Source

clunit-test-report.lisp (file)

Generic Function: suite-list OBJECT

Generic Function: (setf suite-list) NEW-VALUE OBJECT

Package

clunit

Methods

Method: suite-list (CLUNIT-TEST-REPORT clunit-test-report)

Method: (setf suite-list) NEW-VALUE (CLUNIT-TEST-REPORT clunit-test-report)

A list of the suites this test belong.

Source

clunit-test-report.lisp (file)

Generic Function: test-cases OBJECT

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

Package

clunit

Methods

Method: test-cases (CLUNIT-TEST-SUITE clunit-test-suite)

Method: (setf test-cases) NEW-VALUE (CLUNIT-TEST-SUITE clunit-test-suite)

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

Source

clunit-test-suite.lisp (file)

Generic Function: test-function OBJECT

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

Package

clunit

Methods

Method: test-function (CLUNIT-TEST-CASE clunit-test-case)

Method: (setf test-function) NEW-VALUE (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 (file)

Generic Function: (setf test-report-passed) NEW-VALUE OBJECT

Package

clunit

Methods

Method: (setf test-report-passed) NEW-VALUE (CLUNIT-TEST-REPORT clunit-test-report)

Non-nil if the report passed

Source

clunit-test-report.lisp (file)

6.2.5 Conditions

Condition: assertion-condition ()

Package

clunit

Source

assertion-conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

• assertion-passed (condition)
• assertion-error (condition)
• assertion-failed (condition)
• assertion-fail-forced (condition)

Direct methods

print-object (method)

Condition: assertion-error ()

Package

clunit

Source

assertion-conditions.lisp (file)

Direct superclasses

assertion-condition (condition)

Direct methods

• print-format (method)
• print-format (method)

Direct slots

Slot: message

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

Initargs

:message

Initform

(quote "")

Condition: assertion-fail-forced ()

Package

clunit

Source

assertion-conditions.lisp (file)

Direct superclasses

assertion-condition (condition)

Direct methods

• print-format (method)
• print-format (method)

Direct slots

Slot: format-string

the format string argument passed to format.

Initargs

:format-string

Initform

(quote "")

Slot: args

the format string arguments.

Initargs

:args

Initform

(quote "")

Condition: assertion-failed ()

Package

clunit

Source

assertion-conditions.lisp (file)

Direct superclasses

assertion-condition (condition)

Direct methods

• print-format (method)
• print-format (method)

Direct slots

Slot: expression

the expression that was tested.

Initargs

:expression

Initform

(quote nil)

Slot: forms

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

Initargs

:forms

Initform

(quote nil)

Slot: expected

the value the expression was expected to return.

Initargs

:expected

Initform

(quote nil)

Slot: returned

the result that was returned from evaluating the expression.

Initargs

:returned

Initform

(quote nil)

Condition: assertion-passed ()

Package

clunit

Source

assertion-conditions.lisp (file)

Direct superclasses

assertion-condition (condition)

Condition: test-suite-failure ()

Package

clunit

Source

test-suite-failure-conditions.lisp (file)

Direct superclasses

test-suite-failure-condition (condition)

Direct slots

Slot: test-errors

The number of tests with errors.

Initargs

:test-errors

Initform

(quote nil)

Slot: test-failed

The number of tests that failed.

Initargs

:test-fails

Initform

(quote nil)

Slot: total-tests

The total number of tests.

Initargs

:total-tests

Initform

(quote nil)

Condition: test-suite-failure-condition ()

Package

clunit

Source

test-suite-failure-conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

test-suite-failure (condition)

Direct methods

print-format (method)

6.2.6 Classes

Class: clunit-test-case ()

Package

clunit

Source

clunit-test-case.lisp (file)

Direct superclasses

named-class (class)

Direct methods

• test-function (method)
• test-function (method)
• dependencies (method)
• dependencies (method)

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 (generic function)

Writers

(setf dependencies) (generic function)

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 (generic function)

Writers

(setf test-function) (generic 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 (file)

Direct superclasses

named-class (class)

Direct methods

• child-suites (method)
• child-suites (method)
• test-cases (method)
• test-cases (method)

Direct slots

Slot: test-cases

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

Initargs

:test-cases

Readers

test-cases (generic function)

Writers

(setf test-cases) (generic function)

Slot: child-suites

Initargs

:child-suites

Readers

child-suites (generic function)

Writers

(setf child-suites) (generic function)

Class: named-class ()

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

Package

clunit

Source

clunit-test-case.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

• clunit-test-case (class)
• clunit-test-suite (class)

Direct methods

• name (method)
• name (method)

Direct slots

Slot: name

Initargs

:name

Readers

name (generic function)

Writers

(setf name) (generic function)

Appendix A Indexes

A.1 Concepts

A.2 Functions