The clunit Reference Manual

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

The clunit Reference Manual

This is the clunit Reference Manual, version 0.2.3, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:16:20 2022 GMT+0.

Table of Contents


1 Introduction

New Project Steward Required!

This project needs a new maintainer or someone to continue taking it forward. I put a lot of effort and passion to deliver not just a functional but also a beautifully designed and written piece of code. Unfortunately other commitments have crept up over the years, thus I hope someone just as passionate can take over.

CLUnit

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

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

Check out the comprehensive CLUnit Tutorial.

Example

(ql:quickload "clunit")
(use-package :clunit)

;; Test suite for all number operation tests.
(defsuite NumberSuite ())
  
;; Test suite for floating point operations
(defsuite FloatSuite (NumberSuite))
  
(defsuite IntegerSuite (NumberSuite))
    
;; Define a test called TEST-INT1
(deftest test-int1 (IntegerSuite)
    (assert-true  (= 1 1))
    (assert-equalp 4 (+ 2 2)))

;; Define a test called TEST-FLOAT1
(deftest test-float1 (FloatSuite)
    (assert-true (= 1.0 -1.0))
    (assert-equalp 4.0 (+ 2.0 2.0)))

(print (run-suite 'NumberSuite))

which produces the output:

PROGRESS:
=========

    NUMBERSUITE: (Test Suite)

        INTEGERSUITE: (Test Suite)
            TEST-INT1: ..

        FLOATSUITE: (Test Suite)
            TEST-FLOAT1: F.

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

    NUMBERSUITE -> FLOATSUITE: (Test Suite)
        TEST-FLOAT1: Expression: (= 1.0 -1.0)
                     Expected: T
                     Returned: NIL


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

    Tested 4 assertions.
        Passed: 3/4 ( 75.0%)
        Failed: 1/4 ( 25.0%) 

(if you are entering forms in the REPL, the print form is not usually needed).

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


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

produces the output:

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.
        Passed: 0/1 (  0.0%)
        Failed: 1/1 (100.0%)
        Errors: 0/1 (  0.0%)

(if not in a REPL, you may have to print the return value of run-test).


2 Systems

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


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

2.1 clunit

CLUnit is a Common Lisp unit testing framework.

Author

Tapiwa Gutu <tgutu@ml.sun.ac.za>

License

BSD

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

Source

clunit.asd.

Child Component

src (module).


3 Modules

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


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

3.1 clunit/src

Source

clunit.asd.

Parent Component

clunit (system).

Child Components

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

3.2 clunit/src/classes

Dependency

specials.lisp (file).

Source

clunit.asd.

Parent Component

src (module).

Child Components

3.3 clunit/src/functions

Dependency

classes (module).

Source

clunit.asd.

Parent Component

src (module).

Child Components

3.4 clunit/src/report-formats

Dependency

functions (module).

Source

clunit.asd.

Parent Component

src (module).

Child Components

3.5 clunit/src/macros

Dependency

report-formats (module).

Source

clunit.asd.

Parent Component

src (module).

Child Components

4 Files

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


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

4.1 Lisp


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

4.1.1 clunit/clunit.asd

Source

clunit.asd.

Parent Component

clunit (system).

ASDF Systems

clunit.


4.1.2 clunit/src/package.lisp

Source

clunit.asd.

Parent Component

src (module).

Packages

clunit.


4.1.3 clunit/src/specials.lisp

Dependency

package.lisp (file).

Source

clunit.asd.

Parent Component

src (module).

Public Interface
Internals

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

Source

clunit.asd.

Parent Component

classes (module).

Internals

4.1.5 clunit/src/classes/clunit-report.lisp

Source

clunit.asd.

Parent Component

classes (module).

Public Interface

4.1.6 clunit/src/classes/clunit-test-case.lisp

Source

clunit.asd.

Parent Component

classes (module).

Internals

clunit-test-case (class).


4.1.7 clunit/src/classes/clunit-test-suite.lisp

Source

clunit.asd.

Parent Component

classes (module).

Internals

clunit-test-suite (class).


4.1.8 clunit/src/classes/clunit-test-report.lisp

Source

clunit.asd.

Parent Component

classes (module).

Public Interface

4.1.9 clunit/src/functions/assertion-functions.lisp

Source

clunit.asd.

Parent Component

functions (module).

Internals

4.1.10 clunit/src/functions/generic-functions.lisp

Source

clunit.asd.

Parent Component

functions (module).

Internals

4.1.11 clunit/src/functions/test-case-functions.lisp

Source

clunit.asd.

Parent Component

functions (module).

Public Interface
Internals

4.1.12 clunit/src/functions/test-suite-functions.lisp

Source

clunit.asd.

Parent Component

functions (module).

Public Interface
Internals

4.1.13 clunit/src/functions/rerun-failed-tests.lisp

Source

clunit.asd.

Parent Component

functions (module).

Public Interface

rerun-failed-tests (function).


4.1.14 clunit/src/functions/progress-report-functions.lisp

Source

clunit.asd.

Parent Component

functions (module).

Internals

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

Source

clunit.asd.

Parent Component

report-formats (module).

Internals

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

Source

clunit.asd.

Parent Component

report-formats (module).

Internals

4.1.17 clunit/src/report-formats/print-object.lisp

Source

clunit.asd.

Parent Component

report-formats (module).

Public Interface

4.1.18 clunit/src/macros/utility-macros.lisp

Source

clunit.asd.

Parent Component

macros (module).

Internals

4.1.19 clunit/src/macros/assertion-macros.lisp

Dependency

utility-macros.lisp (file).

Source

clunit.asd.

Parent Component

macros (module).

Public Interface
Internals

4.1.20 clunit/src/macros/deffixture.lisp

Dependency

assertion-macros.lisp (file).

Source

clunit.asd.

Parent Component

macros (module).

Public Interface

4.1.21 clunit/src/macros/defsuite.lisp

Dependency

deffixture.lisp (file).

Source

clunit.asd.

Parent Component

macros (module).

Public Interface

4.1.22 clunit/src/macros/deftest.lisp

Dependency

defsuite.lisp (file).

Source

clunit.asd.

Parent Component

macros (module).

Public Interface

5 Packages

Packages are listed by definition order.


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

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.


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

6.1 Public Interface


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

6.1.1 Special variables

Special Variable: *clunit-equality-test*

The equality test used to compare values by the ASSERT-EQUALITY macro.

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.


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.

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) returns true. 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) returns true. 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) returns true. FORMS and their values are printed if the test fails.

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) returns true. FORMS and their values are printed if the test 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.

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) returns true. 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)) returns true. 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 false. FORMS and their values are printed if the test fails.

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.

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

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.

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.

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)
Package

clunit.

Source

assertion-macros.lisp.

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

Returns T 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 T 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)

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.

Package

clunit.

Source

rerun-failed-tests.lisp.

Function: run-suite (suite &key use-debugger report-progress stop-on-fail)

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.

Package

clunit.

Source

test-suite-functions.lisp.

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

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.

Package

clunit.

Source

test-case-functions.lisp.


6.1.4 Generic functions

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

clunit.

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

automatically generated reader method

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

automatically generated reader method

Source

clunit-test-report.lisp.

Target Slot

passed-p.

Generic Reader: test-reports (object)
Package

clunit.

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

automatically generated reader method

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
Package

clunit.

Source

clunit-report.lisp.

Direct methods
Direct slots
Slot: errors
Initform

0

Initargs

:errors

Slot: failed
Initform

0

Initargs

:failed

Slot: passed
Initform

0

Initargs

:passed

Slot: skipped
Initform

0

Initargs

:skipped

Slot: test-reports
Initform

(list)

Readers

test-reports.

Writers

This slot is read-only.

Class: clunit-test-report
Package

clunit.

Source

clunit-test-report.lisp.

Direct methods
Direct slots
Slot: test-name
Initargs

:test-name

Readers

test-report-name.

Writers

This slot is read-only.

Slot: passed-p
Initform

t

Initargs

:passed-p

Readers

test-report-passed-p.

Writers

This slot is read-only.

Slot: skipped-p
Initargs

:skipped-p

Slot: suite-list
Initform

(list)

Initargs

:suite-list

Slot: assertion-conditions
Initform

(list)


6.2 Internals


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

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.

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

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-test-restart (&body body)
Package

clunit.

Source

utility-macros.lisp.


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

6.2.3 Ordinary functions

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

Expands an assertion macro call.

Package

clunit.

Source

assertion-macros.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-SUITES*

Package

clunit.

Source

test-suite-functions.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)
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: (setf get-test-case) (name)

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

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-SUITES*

Package

clunit.

Source

test-suite-functions.lisp.

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

Adds NEW-TEST-SUITE in the hash table *TEST-SUITES* 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 ()
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 ()
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.


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

6.2.4 Generic functions

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


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

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


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

6.2.6 Classes

Class: clunit-test-case
Package

clunit.

Source

clunit-test-case.lisp.

Direct slots
Slot: name
Initargs

:name

Slot: dependencies
Initform

(list)

Initargs

:dependencies

Slot: test-function
Initargs

:test-function

Class: clunit-test-suite
Package

clunit.

Source

clunit-test-suite.lisp.

Direct slots
Slot: name
Initargs

:name

Slot: test-cases
Initform

(list)

Initargs

:test-cases

Slot: child-suites
Initform

(list)

Initargs

:child-suites


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

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

(
(setf get-test-case): Private ordinary functions
(setf get-test-suite): Private ordinary functions

A
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-expander: 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
delete-test-case: Private ordinary functions
delete-test-suite: Private ordinary functions

E
execute-test-case: Private ordinary functions
execute-test-suite: Private ordinary functions
expand-fixture: Private generic functions
expand-fixture: Private generic functions

F
form-expander: Private ordinary functions
Function, (setf get-test-case): Private ordinary functions
Function, (setf get-test-suite): Private ordinary functions
Function, assert-fail: Public ordinary functions
Function, assertion-expander: Private ordinary functions
Function, defined-suite-p: Public ordinary functions
Function, defined-test-p: Public ordinary functions
Function, delete-test-case: Private ordinary functions
Function, delete-test-suite: 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
Generic Function, expand-fixture: Private generic functions
Generic Function, print-format: 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, undeffixture: Public macros
Macro, undefsuite: Public macros
Macro, undeftest: Public macros
Macro, with-assert-restart: Private macros
Macro, with-gensyms: Private macros
Macro, with-test-restart: Private macros
Method, expand-fixture: 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, test-report-name: Public generic functions
Method, test-report-passed-p: Public generic functions
Method, test-reports: Public generic functions

P
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

T
test-case-execution-action: Private ordinary 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-test-restart: Private macros

Jump to:   (  
A   D   E   F   G   H   M   P   Q   R   S   T   U   W  

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

A.3 Variables

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

*
*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-suite-hashtable*: Private special variables
*use-debugger*: Private special variables

A
args: Private conditions
assertion-conditions: Public classes

C
child-suites: Private classes

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
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, 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-function: Private classes
Slot, test-name: Public classes
Slot, test-reports: Public classes
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-suite-hashtable*: Private special variables
Special Variable, *use-debugger*: Private special variables
suite-list: Public classes

T
test-cases: Private classes
test-function: Private classes
test-name: Public classes
test-reports: Public classes

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

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

A.4 Data types

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

A
assertion-condition: Private conditions
assertion-conditions.lisp: The clunit/src/classes/assertion-conditions․lisp file
assertion-error: Private conditions
assertion-fail-forced: Private conditions
assertion-failed: Private conditions
assertion-functions.lisp: The clunit/src/functions/assertion-functions․lisp file
assertion-macros.lisp: The clunit/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
classes: The clunit/src/classes module
clunit: The clunit system
clunit: The clunit package
clunit-report: Public classes
clunit-report.lisp: The clunit/src/classes/clunit-report․lisp file
clunit-test-case: Private classes
clunit-test-case.lisp: The clunit/src/classes/clunit-test-case․lisp file
clunit-test-report: Public classes
clunit-test-report.lisp: The clunit/src/classes/clunit-test-report․lisp file
clunit-test-suite: Private classes
clunit-test-suite.lisp: The clunit/src/classes/clunit-test-suite․lisp file
clunit.asd: The clunit/clunit․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

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

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

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

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

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

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

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

T
test-case-functions.lisp: The clunit/src/functions/test-case-functions․lisp file
test-suite-functions.lisp: The clunit/src/functions/test-suite-functions․lisp file

U
utility-macros.lisp: The clunit/src/macros/utility-macros․lisp file

Jump to:   A   C   D   F   G   M   P   R   S   T   U