The kaputt Reference Manual

This is the kaputt Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 04:09:17 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 kaputt

A Simple Interactive Test Framework for Common Lisp

Author

Michaël Le Barbier

Home Page

https://github.com/michipili/cl-kaputt

License

CeCILL-B

Dependency

alexandria (system).

Source

kaputt.asd.

Child Component

src (module).


3 Modules

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


3.1 kaputt/src

Source

kaputt.asd.

Parent Component

kaputt (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 kaputt/kaputt.asd

Source

kaputt.asd.

Parent Component

kaputt (system).

ASDF Systems

kaputt.


4.1.2 kaputt/src/package.lisp

Source

kaputt.asd.

Parent Component

src (module).

Packages

kaputt.


4.1.3 kaputt/src/utilities.lisp

Source

kaputt.asd.

Parent Component

src (module).

Internals

4.1.4 kaputt/src/configuration.lisp

Source

kaputt.asd.

Parent Component

src (module).

Internals

*batch-mode* (special variable).


4.1.5 kaputt/src/assert.lisp

Source

kaputt.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.6 kaputt/src/result.lisp

Source

kaputt.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.7 kaputt/src/supervisor.lisp

Source

kaputt.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.8 kaputt/src/testcase.lisp

Source

kaputt.asd.

Parent Component

src (module).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


5.1 kaputt

The Kaputt Test Framework.

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Macros

Macro: assert-condition (form condition &optional slots &body body)

The assertion (ASSERT-CONDITION CONDITION FORM) is true iff FORM yields CONDITION.
It is possible to perform arbitrary checks on the condition by providing SLOTS, which are bound to the generated condition slots as in WITH-SLOTS and the given BODY yielding a generalised boolean validating details of the assertion.

Package

kaputt.

Source

assert.lisp.

Macro: assert-failure (form &optional pattern)

An assertion that verifies that the assertion FORM yields a failure. When a globbing PATTERN is supplied the description of the failure is matched against it.

Package

kaputt.

Source

testcase.lisp.

Macro: define-assertion (name lambda-list &body body)

Define an assertion function NAME, accepting LAMBDA-LIST with BODY.
The BODY is interpreted as computing a generalised boolean value,
which determines if the assertion is a success or failure. When it is a success,
a single value T is returned. When it is a failure, two values NIL and a descriptive string are returned.

The NAME must start with ASSERT-, ASSERT<, ASSERT> or ASSERT=.

When the first BODY form is a string, this string is used as an informational message when reporting the corresponding error condition. It is also used as a documentaion string for the created function.

When the next BODY form starts with the keyword :REPORT, then the rest of that form must be function of a STREAM. This function is then used to generate an informational message when reporting the corresponding error condition. This allows to add dynamic context to this informational messsage, like the value of some variables.

Package

kaputt.

Source

assert.lisp.

Macro: define-testcase (testcase-name testcase-args &body body)

Define a test case function TESTCASE-NAME, accepting TESTCASE-ARGS with BODY.

The BODY is examined and assertions spotted in it are wrapped with extra code
installing restarts and triggering supervisor events.

Test cases are allowed to be nested. A toplevel test case is a test suite and triggers testsuite supervisor events when beginning and ending. The return value of a testcase is a boolean which is true iff the current testsuite has experienced a failed assertion. Thus, even if a test case does not experience any failure, a NIL value is returned if a previous test case in the current test suite has experienced a failure.

Package

kaputt.

Source

testcase.lisp.

Macro: testcase-batch (&body forms)

Run FORMS in an environment where testcase are batched.

Package

kaputt.

Source

testcase.lisp.

Macro: testcase-continue (&body forms)

Run FORMS in an environment where testcase failures are continued.

Package

kaputt.

Source

testcase.lisp.

Macro: testcase-ignore (&body forms)

Run FORMS in an environment where testcase failures are ignored.

Package

kaputt.

Source

testcase.lisp.


6.1.2 Ordinary functions

Function: assert-eq (a b)

The assertion (ASSERT-EQ A B) is true, iff A and B satisfy the EQ predicate.

Package

kaputt.

Source

assert.lisp.

Function: assert-eql (a b)

The assertion (ASSERT-EQL A B) is true, iff A and B satisfy the EQL predicate.

Package

kaputt.

Source

assert.lisp.

Function: assert-equal (a b)

The assertion (ASSERT-EQUAL A B) is true, iff A and B satisfy the EQUAL predicate.

Package

kaputt.

Source

assert.lisp.

Function: assert-float-is-approximately-equal (float1 float2 &optional inaccuracy)

The assertion (ASSERT-FLOAT-IS-APPROXIMATELY-EQUAL FLOAT1 FLOAT2) is true iff FLOAT1 and FLOAT2 are in a neighbourhood whose size is based on the magnitude orders of FLOAT1 and FLOAT2 and the floating point precision.

Package

kaputt.

Source

assert.lisp.

Function: assert-float-is-definitely-greater-than (float1 float2 &optional inaccuracy)

The assertion (ASSERT-FLOAT-IS-DEFINITELY-GREATER-THAN FLOAT1 FLOAT2) is true iff FLOAT1 is greater than FLOAT2 and not in a neighbourhood of FLOAT2 whose diameter is controlled by the INACCURACY, the magnitude orders of FLOAT1 and FLOAT2 and the floating point precision.

Package

kaputt.

Source

assert.lisp.

Function: assert-float-is-definitely-less-than (float1 float2 &optional inaccuracy)

The assertion (ASSERT-FLOAT-IS-DEFINITELY-LESS-THAN FLOAT1 FLOAT2) is true iff FLOAT2
is greater than FLOAT1 and not in a neighbourhood of FLOAT1 whose diameter is controlled by the INACCURACY, the magnitude orders of FLOAT1 and FLOAT2 and the floating point precision.

Package

kaputt.

Source

assert.lisp.

Function: assert-float-is-essentially-equal (float1 float2 &optional inaccuracy)

The assertion (ASSERT-FLOAT-IS-ESSENTIALLY-EQUAL FLOAT1 FLOAT2) is true iff FLOAT1 and FLOAT2 are in a neighbourhood whose size is based on the magnitude orders of FLOAT1 and FLOAT2 and the floating point precision.

Package

kaputt.

Source

assert.lisp.

Function: assert-nil (expr)

The assertion (ASSERT-NIL EXPR) is true, iff EXPR is NIL.

Package

kaputt.

Source

assert.lisp.

Function: assert-set-equal (list1 list2 &key key test)

The assertion (ASSERT-SET-EQUAL LIST1 LIST2) is true iff LIST1 denotes the same set as LIST2.

Package

kaputt.

Source

assert.lisp.

Function: assert-string-equal (string1 string2 &key start1 end1 start2 end2)

The assertion (ASSERT-STRING-EQUAL STRING1 STRING2) is true, iff STRING1 and STRING2 satisfy the STRING-EQUAL predicate.
This assertion supports the same keyword parameters as STRING-EQUAL.

Package

kaputt.

Source

assert.lisp.

Function: assert-string< (string1 string2 &key start1 end1 start2 end2)

The assertion (ASSERT-STRING< STRING1 STRING2) is true, iff STRING1 and STRING2 satisfy the STRING< predicate.
This assertion supports the same keyword parameters as STRING<.

Package

kaputt.

Source

assert.lisp.

Function: assert-string<= (string1 string2 &key start1 end1 start2 end2)

The assertion (ASSERT-STRING<= STRING1 STRING2) is true, iff STRING1 and STRING2 satisfy the STRING<= predicate.
This assertion supports the same keyword parameters as STRING<=.

Package

kaputt.

Source

assert.lisp.

Function: assert-string= (string1 string2 &key start1 end1 start2 end2)

The assertion (ASSERT-STRING= STRING1 STRING2) is true, iff STRING1 and STRING2 satisfy the STRING= predicate.
This assertion supports the same keyword parameters as STRING=.

Package

kaputt.

Source

assert.lisp.

Function: assert-string> (string1 string2 &key start1 end1 start2 end2)

The assertion (ASSERT-STRING> STRING1 STRING2) is true, iff STRING1 and STRING2 satisfy the STRING> predicate.
This assertion supports the same keyword parameters as STRING>.

Package

kaputt.

Source

assert.lisp.

Function: assert-string>= (string1 string2 &key start1 end1 start2 end2)

The assertion (ASSERT-STRING>= STRING1 STRING2) is true, iff STRING1 and STRING2 satisfy the STRING>= predicate.
This assertion supports the same keyword parameters as STRING>=.

Package

kaputt.

Source

assert.lisp.

Function: assert-subsetp (list1 list2 &key key test)

The assertion (ASSERT-SUBSETP LIST1 LIST2) is true iff LIST1 is a subset of LIST2.

Package

kaputt.

Source

assert.lisp.

Function: assert-t (expr)

The assertion (ASSERT-T EXPR) is true, iff EXPR is T.

Package

kaputt.

Source

assert.lisp.

Function: assert-t* (expr)

The assertion (ASSERT-T* EXPR) is true, iff EXPR is true as a generalised boolean.

Package

kaputt.

Source

assert.lisp.

Function: assert-type (expr type)

The assertion (ASSERT-TYPE EXPR TYPE) is true, iff EXPR evaluates to a value of type TYPE.

Package

kaputt.

Source

assert.lisp.

Function: assert-vector-equal (vector1 vector2 &key test)

The assertion (ASSERT-VECTOR-EQUAL VECTOR1 VECTOR2) is true iff VECTOR1 and VECTOR2 are equal. Vectors are equal if they have the same length and have equal elements at each
index. The equality predicate used to compare elements is either EQL or the predicate provided by the :TEST keyword argument.

Package

kaputt.

Source

assert.lisp.

Function: assert< (a b)

The assertion (ASSERT< A B) is true, iff A and B satisfy the < predicate.

Package

kaputt.

Source

assert.lisp.

Function: assert<= (a b)

The assertion (ASSERT<= A B) is true, iff A and B satisfy the <= predicate.

Package

kaputt.

Source

assert.lisp.

Function: assert= (a b)

The assertion (ASSERT= A B) is true, iff A and B satisfy the = predicate.

Package

kaputt.

Source

assert.lisp.

Function: assert> (a b)

The assertion (ASSERT> A B) is true, iff A and B satisfy the > predicate.

Package

kaputt.

Source

assert.lisp.

Function: assert>= (a b)

The assertion (ASSERT>= A B) is true, iff A and B satisfy the >= predicate.

Package

kaputt.

Source

assert.lisp.

Reader: assertion-arguments (instance)
Writer: (setf assertion-arguments) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

arguments.

Reader: assertion-condition (instance)
Writer: (setf assertion-condition) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

condition.

Reader: assertion-description (instance)
Writer: (setf assertion-description) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

description.

Reader: assertion-form (instance)
Writer: (setf assertion-form) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

form.

Reader: assertion-name (instance)
Writer: (setf assertion-name) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

name.

Reader: assertion-outcome (instance)
Writer: (setf assertion-outcome) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

outcome.

Function: assertion-p (object)
Package

kaputt.

Source

result.lisp.

Reader: assertion-path (instance)
Writer: (setf assertion-path) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

path.

Reader: assertion-type (instance)
Writer: (setf assertion-type) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

type.

Function: make-assertion (&key name path arguments form type outcome description condition)
Package

kaputt.

Source

result.lisp.

Function: make-testcase (&key name path arguments total success failure condition skip results)
Package

kaputt.

Source

result.lisp.

Reader: testcase-arguments (instance)
Writer: (setf testcase-arguments) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

arguments.

Reader: testcase-condition (instance)
Writer: (setf testcase-condition) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

condition.

Reader: testcase-failure (instance)
Writer: (setf testcase-failure) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

failure.

Reader: testcase-name (instance)
Writer: (setf testcase-name) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

name.

Function: testcase-p (object)
Package

kaputt.

Source

result.lisp.

Reader: testcase-path (instance)
Writer: (setf testcase-path) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

path.

Reader: testcase-results (instance)
Writer: (setf testcase-results) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

results.

Reader: testcase-skip (instance)
Writer: (setf testcase-skip) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

skip.

Reader: testcase-success (instance)
Writer: (setf testcase-success) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

success.

Reader: testcase-total (instance)
Writer: (setf testcase-total) (instance)
Package

kaputt.

Source

result.lisp.

Target Slot

total.


6.1.3 Generic functions

Generic Function: supervisor-assertion (supervisor assertion)

This event is sent to a supervisor when an assertion has been performed.

Package

kaputt.

Source

supervisor.lisp.

Method Combination

progn.

Options

:most-specific-first

Methods
Method: supervisor-assertion progn ((instance serviceable-supervisor) assertion)
Method: supervisor-assertion progn ((instance pointless-supervisor) assertion)
Method: supervisor-assertion progn ((instance tally-supervisor) assertion)
Method: supervisor-assertion progn ((instance trace-supervisor) assertion)
Method: supervisor-assertion progn ((instance null) assertion)
Method: supervisor-assertion progn ((instance supervisor) assertion)
Generic Function: supervisor-success-p (supervisor)

This method tells if a test suite has never recorded a failure.

Package

kaputt.

Source

supervisor.lisp.

Methods
Method: supervisor-success-p ((instance null))
Method: supervisor-success-p ((instance supervisor))
Generic Function: supervisor-testcase-begin (supervisor testcase)

This event is sent to a supervisor when a test case begins.

Package

kaputt.

Source

supervisor.lisp.

Method Combination

progn.

Options

:most-specific-first

Methods
Method: supervisor-testcase-begin progn ((instance tally-supervisor) testcase)
Method: supervisor-testcase-begin progn ((instance trace-supervisor) testcase)
Method: supervisor-testcase-begin progn ((instance null) testcase)
Method: supervisor-testcase-begin progn ((instance supervisor) testcase)
Generic Function: supervisor-testcase-end (supervisor testcase outcome)

This event is sent to a supervisor when a test case ends.

Package

kaputt.

Source

supervisor.lisp.

Method Combination

progn.

Options

:most-specific-first

Methods
Method: supervisor-testcase-end progn ((instance trace-supervisor) testcase outcome)
Method: supervisor-testcase-end progn ((instance null) testcase outcome)
Method: supervisor-testcase-end progn ((instance supervisor) testcase outcome)

6.1.4 Structures

Structure: assertion

A strucure capturing an assertion result.
Slots are populated as follows:

NAME:
The symbol designating the assertion. This is the first element of the FORM.

PATH:
The path of the assertion in the test hierarchy. This the stack of preceding testcases in the test hierarchy.

ARGUMENTS:
The list of evaluated arguments for the assertion.

FORM:
The form for the assertion invocation.

TYPE:
One of the keywords :FUNCTION or :MACRO.

OUTCOME:
One of the keywords :SUCCESS, :FAILURE or :CONDITION.

DESCRIPTION:
When the OUTCOME is :SUCCESS, this is NIL. When the OUTCOME is :FAILURE, the failure description provided by the assertion as a second value. When the OUTCOME is :CONDITION, the description of the condition.

CONDITION:
When the OUTCOME is :CONDITION, the condition.

Package

kaputt.

Source

result.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Readers

assertion-name.

Writers

(setf assertion-name).

Slot: path
Readers

assertion-path.

Writers

(setf assertion-path).

Slot: arguments
Readers

assertion-arguments.

Writers

(setf assertion-arguments).

Slot: form
Readers

assertion-form.

Writers

(setf assertion-form).

Slot: type
Package

common-lisp.

Readers

assertion-type.

Writers

(setf assertion-type).

Slot: outcome
Readers

assertion-outcome.

Writers

(setf assertion-outcome).

Slot: description
Readers

assertion-description.

Writers

(setf assertion-description).

Slot: condition
Package

common-lisp.

Readers

assertion-condition.

Writers

(setf assertion-condition).

Structure: testcase

A structure capturing a testcase result.
Slots are populated as follows:

NAME:
The symbol designating the testcase.

PATH:
The path of the testcase in the test hierarchy. This the stack of preceding testcases in the test hierarchy.

ARGUMENTS:
The list of evaluated arguments for the testcase.

TOTAL:
The total number of assertions in the testcase and its descendants.

SUCCESS:
The total number of assertions that yielded a :SUCCESS in the testcase and its descendants.

FAILURE:
The total number of assertions that yielded a :FAILURE in the testcase and its descendants.

CONDITION:
The total number of assertions that yielded a :CONDITION in the testcase and its descendants.

SKIP:
The total number of assertions that yielded a :SKIP in the testcase and its descendants.

RESULTS:
The list of testcase results and assertions results yielded by descendants.

Package

kaputt.

Source

result.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Readers

testcase-name.

Writers

(setf testcase-name).

Slot: path
Readers

testcase-path.

Writers

(setf testcase-path).

Slot: arguments
Readers

testcase-arguments.

Writers

(setf testcase-arguments).

Slot: total
Readers

testcase-total.

Writers

(setf testcase-total).

Slot: success
Readers

testcase-success.

Writers

(setf testcase-success).

Slot: failure
Readers

testcase-failure.

Writers

(setf testcase-failure).

Slot: condition
Package

common-lisp.

Readers

testcase-condition.

Writers

(setf testcase-condition).

Slot: skip
Readers

testcase-skip.

Writers

(setf testcase-skip).

Slot: results
Readers

testcase-results.

Writers

(setf testcase-results).


6.1.5 Classes

Class: supervisor

This class models test suite execution supervisors.
When running a test suite, the progress and results of the execution are recorded in a SUPERVISOR instance.

Descendants of this class provide more functionalities.

Package

kaputt.

Source

supervisor.lisp.

Direct subclasses

verbose-supervisor.

Direct methods
Direct slots
Slot: success-p
Initform

t


6.2 Internals


6.2.1 Special variables

Special Variable: *batch-mode*

When *BATCH-MODE* is NIL, the debugger will pop-up on failed assertions, unless the operator has required to scroll through errors when restarting on a previous error of the current testcase.

Package

kaputt.

Source

configuration.lisp.

Special Variable: *current-supervisor*

The current supervisor.

Package

kaputt.

Source

supervisor.lisp.

Special Variable: *double-float-precision*
Package

kaputt.

Source

assert.lisp.

Special Variable: *testcase-interaction*

The interaction mode for running testcases.
Accepted values are NIL, :RETRY, :CONTINUE, :IGNORE or :SKIP.

When the SWANK feature is active, we assume interactive use of the system and initialise the interaction mode to :RETRY. It is set to NIL otherwise.

Package

kaputt.

Source

testcase.lisp.

Special Variable: *testcase-path*

The current path in the testcase hierarchy.
When running in a testcase, the first elements of *testcase-path* designate this specific testcase.

Package

kaputt.

Source

testcase.lisp.

Special Variable: *testcase-results*

The accumulated results of the current testcase. This is NIL when not running in a testcase.

Package

kaputt.

Source

testcase.lisp.

Special Variable: *testcase-skip*

Flag governing skipping assertions in the current testcase.

Package

kaputt.

Source

testcase.lisp.

Special Variable: *testcase-supervisor-class*

The supervisor class to use when running test suites.

Package

kaputt.

Source

testcase.lisp.


6.2.2 Macros

Macro: description (&rest forms)

Concatenate initial FORMS which are strings and use this as a control string.

Package

kaputt.

Source

utilities.lisp.

Macro: float-comparison-threshold (binop k u v)
Package

kaputt.

Source

assert.lisp.

Macro: restart-assertion (form)

Supervise the execution of FORM with restarts.

Package

kaputt.

Source

testcase.lisp.

Macro: supervise-assertion (form)

Supervise the execution of the assertion FORM and return ASSERTION evaluation details.

Package

kaputt.

Source

testcase.lisp.


6.2.3 Ordinary functions

Function: assert-failure/main (form pattern success-p assertion-description)

Handle the main line for ASSERT-FAILURE.

Package

kaputt.

Source

testcase.lisp.

Function: assert-failure/unexpected-condition (form unexpected-condition)

Handle unexpected conditions in ASSERT-FAILURE.

Package

kaputt.

Source

testcase.lisp.

Function: assertion-failed/report (details-designator stream)
Package

kaputt.

Source

testcase.lisp.

Function: copy-assertion (instance)
Package

kaputt.

Source

result.lisp.

Function: copy-testcase (instance)
Package

kaputt.

Source

result.lisp.

Function: count-total-number-of-assertions (results)

Count the total number of assertions in RESULTS.

Package

kaputt.

Source

result.lisp.

Function: count-total-number-of-assertions-by-outcome (results outcome)

Count the total number of assertions in RESULTS that yielded a OUTCOME.

Package

kaputt.

Source

result.lisp.

Function: define-testcase/wrap-assert-form (body-forms)

Walks through BODY-FORMS and wrap assertion forms in a RESTART-CASE.

Package

kaputt.

Source

testcase.lisp.

Function: report-string-comparison (comparison string1 string2)
Package

kaputt.

Source

assert.lisp.

Function: report-string-comparison/details (stream comparison string1 string2)
Package

kaputt.

Source

assert.lisp.

Function: report-string-comparison/unexpected-type (stream label object)
Package

kaputt.

Source

assert.lisp.

Function: string-match (pattern text)

Predicate recognising TEXT matching a globbing PATTERN.

Package

kaputt.

Source

utilities.lisp.


6.2.4 Generic functions

Generic Function: supervisor-toplevel-begin (supervisor)

This event is sent to a supervisor, when a test suite starts. This is the appropriate place to prepare output files, register starting time and so on.

Package

kaputt.

Source

supervisor.lisp.

Method Combination

progn.

Options

:most-specific-first

Methods
Method: supervisor-toplevel-begin progn ((instance null))
Method: supervisor-toplevel-begin progn ((instance supervisor))
Generic Function: supervisor-toplevel-end (supervisor results)

This event is sent to a supervisor when a test suite ends. This is the appopriate place to close output files, display aggregated reports.

Package

kaputt.

Source

supervisor.lisp.

Method Combination

progn.

Options

:most-specific-first

Methods
Method: supervisor-toplevel-end progn ((instance tally-supervisor) results)
Method: supervisor-toplevel-end progn ((instance null) results)
Method: supervisor-toplevel-end progn ((instance supervisor) results)

6.2.5 Conditions

Condition: assertion-failed
Package

kaputt.

Source

testcase.lisp.

Direct superclasses

serious-condition.

Direct slots
Slot: details
Initargs

:details


6.2.6 Classes

Class: pointless-supervisor

A pointless supervisor reports assertion progress with dots and capital letter E, for success and errors respectively. At the end of a testsuite, it prints basic counts describing the current testsuite and a detailed failure report.

Package

kaputt.

Source

supervisor.lisp.

Direct superclasses

tally-supervisor.

Direct methods

supervisor-assertion.

Direct slots
Slot: width
Initform

70

Class: serviceable-supervisor

A serviceable supervisor reports assertion failures as they come. At the end of the toplevel testsuite it displays a tally of the failures.

Package

kaputt.

Source

supervisor.lisp.

Direct superclasses

tally-supervisor.

Direct methods

supervisor-assertion.

Direct slots
Slot: width
Initform

70

Class: tally-supervisor

A tally supervisor counts TESTCASE and ASSERTION by their outcomes. At the end of a testsuite, it prints basic counts describing the current testsuite and a detailed failure report.

Package

kaputt.

Source

supervisor.lisp.

Direct superclasses

verbose-supervisor.

Direct subclasses
Direct methods
Direct slots
Slot: testcase-count
Initform

0

Slot: assertion-count
Initform

0

Slot: success-count
Initform

0

Slot: failure-count
Initform

0

Slot: condition-count
Initform

0

Slot: skip-count
Initform

0

Class: trace-supervisor

A trace supervisor reports each event sent to it.

Package

kaputt.

Source

supervisor.lisp.

Direct superclasses

verbose-supervisor.

Direct methods
Class: verbose-supervisor

A verbose supervisor owns a STREAM-OUTPUT.

Package

kaputt.

Source

supervisor.lisp.

Direct superclasses

supervisor.

Direct subclasses
Direct slots
Slot: stream-output
Initform

*standard-output*


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

(
(setf assertion-arguments): Public ordinary functions
(setf assertion-condition): Public ordinary functions
(setf assertion-description): Public ordinary functions
(setf assertion-form): Public ordinary functions
(setf assertion-name): Public ordinary functions
(setf assertion-outcome): Public ordinary functions
(setf assertion-path): Public ordinary functions
(setf assertion-type): Public ordinary functions
(setf testcase-arguments): Public ordinary functions
(setf testcase-condition): Public ordinary functions
(setf testcase-failure): Public ordinary functions
(setf testcase-name): Public ordinary functions
(setf testcase-path): Public ordinary functions
(setf testcase-results): Public ordinary functions
(setf testcase-skip): Public ordinary functions
(setf testcase-success): Public ordinary functions
(setf testcase-total): Public ordinary functions

A
assert-condition: Public macros
assert-eq: Public ordinary functions
assert-eql: Public ordinary functions
assert-equal: Public ordinary functions
assert-failure: Public macros
assert-failure/main: Private ordinary functions
assert-failure/unexpected-condition: Private ordinary functions
assert-float-is-approximately-equal: Public ordinary functions
assert-float-is-definitely-greater-than: Public ordinary functions
assert-float-is-definitely-less-than: Public ordinary functions
assert-float-is-essentially-equal: Public ordinary functions
assert-nil: Public ordinary functions
assert-set-equal: Public ordinary functions
assert-string-equal: Public ordinary functions
assert-string<: Public ordinary functions
assert-string<=: Public ordinary functions
assert-string=: Public ordinary functions
assert-string>: Public ordinary functions
assert-string>=: Public ordinary functions
assert-subsetp: Public ordinary functions
assert-t: Public ordinary functions
assert-t*: Public ordinary functions
assert-type: Public ordinary functions
assert-vector-equal: Public ordinary functions
assert<: Public ordinary functions
assert<=: Public ordinary functions
assert=: Public ordinary functions
assert>: Public ordinary functions
assert>=: Public ordinary functions
assertion-arguments: Public ordinary functions
assertion-condition: Public ordinary functions
assertion-description: Public ordinary functions
assertion-failed/report: Private ordinary functions
assertion-form: Public ordinary functions
assertion-name: Public ordinary functions
assertion-outcome: Public ordinary functions
assertion-p: Public ordinary functions
assertion-path: Public ordinary functions
assertion-type: Public ordinary functions

C
copy-assertion: Private ordinary functions
copy-testcase: Private ordinary functions
count-total-number-of-assertions: Private ordinary functions
count-total-number-of-assertions-by-outcome: Private ordinary functions

D
define-assertion: Public macros
define-testcase: Public macros
define-testcase/wrap-assert-form: Private ordinary functions
description: Private macros

F
float-comparison-threshold: Private macros
Function, (setf assertion-arguments): Public ordinary functions
Function, (setf assertion-condition): Public ordinary functions
Function, (setf assertion-description): Public ordinary functions
Function, (setf assertion-form): Public ordinary functions
Function, (setf assertion-name): Public ordinary functions
Function, (setf assertion-outcome): Public ordinary functions
Function, (setf assertion-path): Public ordinary functions
Function, (setf assertion-type): Public ordinary functions
Function, (setf testcase-arguments): Public ordinary functions
Function, (setf testcase-condition): Public ordinary functions
Function, (setf testcase-failure): Public ordinary functions
Function, (setf testcase-name): Public ordinary functions
Function, (setf testcase-path): Public ordinary functions
Function, (setf testcase-results): Public ordinary functions
Function, (setf testcase-skip): Public ordinary functions
Function, (setf testcase-success): Public ordinary functions
Function, (setf testcase-total): Public ordinary functions
Function, assert-eq: Public ordinary functions
Function, assert-eql: Public ordinary functions
Function, assert-equal: Public ordinary functions
Function, assert-failure/main: Private ordinary functions
Function, assert-failure/unexpected-condition: Private ordinary functions
Function, assert-float-is-approximately-equal: Public ordinary functions
Function, assert-float-is-definitely-greater-than: Public ordinary functions
Function, assert-float-is-definitely-less-than: Public ordinary functions
Function, assert-float-is-essentially-equal: Public ordinary functions
Function, assert-nil: Public ordinary functions
Function, assert-set-equal: Public ordinary functions
Function, assert-string-equal: Public ordinary functions
Function, assert-string<: Public ordinary functions
Function, assert-string<=: Public ordinary functions
Function, assert-string=: Public ordinary functions
Function, assert-string>: Public ordinary functions
Function, assert-string>=: Public ordinary functions
Function, assert-subsetp: Public ordinary functions
Function, assert-t: Public ordinary functions
Function, assert-t*: Public ordinary functions
Function, assert-type: Public ordinary functions
Function, assert-vector-equal: Public ordinary functions
Function, assert<: Public ordinary functions
Function, assert<=: Public ordinary functions
Function, assert=: Public ordinary functions
Function, assert>: Public ordinary functions
Function, assert>=: Public ordinary functions
Function, assertion-arguments: Public ordinary functions
Function, assertion-condition: Public ordinary functions
Function, assertion-description: Public ordinary functions
Function, assertion-failed/report: Private ordinary functions
Function, assertion-form: Public ordinary functions
Function, assertion-name: Public ordinary functions
Function, assertion-outcome: Public ordinary functions
Function, assertion-p: Public ordinary functions
Function, assertion-path: Public ordinary functions
Function, assertion-type: Public ordinary functions
Function, copy-assertion: Private ordinary functions
Function, copy-testcase: Private ordinary functions
Function, count-total-number-of-assertions: Private ordinary functions
Function, count-total-number-of-assertions-by-outcome: Private ordinary functions
Function, define-testcase/wrap-assert-form: Private ordinary functions
Function, make-assertion: Public ordinary functions
Function, make-testcase: Public ordinary functions
Function, report-string-comparison: Private ordinary functions
Function, report-string-comparison/details: Private ordinary functions
Function, report-string-comparison/unexpected-type: Private ordinary functions
Function, string-match: Private ordinary functions
Function, testcase-arguments: Public ordinary functions
Function, testcase-condition: Public ordinary functions
Function, testcase-failure: Public ordinary functions
Function, testcase-name: Public ordinary functions
Function, testcase-p: Public ordinary functions
Function, testcase-path: Public ordinary functions
Function, testcase-results: Public ordinary functions
Function, testcase-skip: Public ordinary functions
Function, testcase-success: Public ordinary functions
Function, testcase-total: Public ordinary functions

G
Generic Function, supervisor-assertion: Public generic functions
Generic Function, supervisor-success-p: Public generic functions
Generic Function, supervisor-testcase-begin: Public generic functions
Generic Function, supervisor-testcase-end: Public generic functions
Generic Function, supervisor-toplevel-begin: Private generic functions
Generic Function, supervisor-toplevel-end: Private generic functions

M
Macro, assert-condition: Public macros
Macro, assert-failure: Public macros
Macro, define-assertion: Public macros
Macro, define-testcase: Public macros
Macro, description: Private macros
Macro, float-comparison-threshold: Private macros
Macro, restart-assertion: Private macros
Macro, supervise-assertion: Private macros
Macro, testcase-batch: Public macros
Macro, testcase-continue: Public macros
Macro, testcase-ignore: Public macros
make-assertion: Public ordinary functions
make-testcase: Public ordinary functions
Method, supervisor-assertion: Public generic functions
Method, supervisor-assertion: Public generic functions
Method, supervisor-assertion: Public generic functions
Method, supervisor-assertion: Public generic functions
Method, supervisor-assertion: Public generic functions
Method, supervisor-assertion: Public generic functions
Method, supervisor-success-p: Public generic functions
Method, supervisor-success-p: Public generic functions
Method, supervisor-testcase-begin: Public generic functions
Method, supervisor-testcase-begin: Public generic functions
Method, supervisor-testcase-begin: Public generic functions
Method, supervisor-testcase-begin: Public generic functions
Method, supervisor-testcase-end: Public generic functions
Method, supervisor-testcase-end: Public generic functions
Method, supervisor-testcase-end: Public generic functions
Method, supervisor-toplevel-begin: Private generic functions
Method, supervisor-toplevel-begin: Private generic functions
Method, supervisor-toplevel-end: Private generic functions
Method, supervisor-toplevel-end: Private generic functions
Method, supervisor-toplevel-end: Private generic functions

R
report-string-comparison: Private ordinary functions
report-string-comparison/details: Private ordinary functions
report-string-comparison/unexpected-type: Private ordinary functions
restart-assertion: Private macros

S
string-match: Private ordinary functions
supervise-assertion: Private macros
supervisor-assertion: Public generic functions
supervisor-assertion: Public generic functions
supervisor-assertion: Public generic functions
supervisor-assertion: Public generic functions
supervisor-assertion: Public generic functions
supervisor-assertion: Public generic functions
supervisor-assertion: Public generic functions
supervisor-success-p: Public generic functions
supervisor-success-p: Public generic functions
supervisor-success-p: Public generic functions
supervisor-testcase-begin: Public generic functions
supervisor-testcase-begin: Public generic functions
supervisor-testcase-begin: Public generic functions
supervisor-testcase-begin: Public generic functions
supervisor-testcase-begin: Public generic functions
supervisor-testcase-end: Public generic functions
supervisor-testcase-end: Public generic functions
supervisor-testcase-end: Public generic functions
supervisor-testcase-end: Public generic functions
supervisor-toplevel-begin: Private generic functions
supervisor-toplevel-begin: Private generic functions
supervisor-toplevel-begin: Private generic functions
supervisor-toplevel-end: Private generic functions
supervisor-toplevel-end: Private generic functions
supervisor-toplevel-end: Private generic functions
supervisor-toplevel-end: Private generic functions

T
testcase-arguments: Public ordinary functions
testcase-batch: Public macros
testcase-condition: Public ordinary functions
testcase-continue: Public macros
testcase-failure: Public ordinary functions
testcase-ignore: Public macros
testcase-name: Public ordinary functions
testcase-p: Public ordinary functions
testcase-path: Public ordinary functions
testcase-results: Public ordinary functions
testcase-skip: Public ordinary functions
testcase-success: Public ordinary functions
testcase-total: Public ordinary functions


A.3 Variables

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

*
*batch-mode*: Private special variables
*current-supervisor*: Private special variables
*double-float-precision*: Private special variables
*testcase-interaction*: Private special variables
*testcase-path*: Private special variables
*testcase-results*: Private special variables
*testcase-skip*: Private special variables
*testcase-supervisor-class*: Private special variables

A
arguments: Public structures
arguments: Public structures
assertion-count: Private classes

C
condition: Public structures
condition: Public structures
condition-count: Private classes

D
description: Public structures
details: Private conditions

F
failure: Public structures
failure-count: Private classes
form: Public structures

N
name: Public structures
name: Public structures

O
outcome: Public structures

P
path: Public structures
path: Public structures

R
results: Public structures

S
skip: Public structures
skip-count: Private classes
Slot, arguments: Public structures
Slot, arguments: Public structures
Slot, assertion-count: Private classes
Slot, condition: Public structures
Slot, condition: Public structures
Slot, condition-count: Private classes
Slot, description: Public structures
Slot, details: Private conditions
Slot, failure: Public structures
Slot, failure-count: Private classes
Slot, form: Public structures
Slot, name: Public structures
Slot, name: Public structures
Slot, outcome: Public structures
Slot, path: Public structures
Slot, path: Public structures
Slot, results: Public structures
Slot, skip: Public structures
Slot, skip-count: Private classes
Slot, stream-output: Private classes
Slot, success: Public structures
Slot, success-count: Private classes
Slot, success-p: Public classes
Slot, testcase-count: Private classes
Slot, total: Public structures
Slot, type: Public structures
Slot, width: Private classes
Slot, width: Private classes
Special Variable, *batch-mode*: Private special variables
Special Variable, *current-supervisor*: Private special variables
Special Variable, *double-float-precision*: Private special variables
Special Variable, *testcase-interaction*: Private special variables
Special Variable, *testcase-path*: Private special variables
Special Variable, *testcase-results*: Private special variables
Special Variable, *testcase-skip*: Private special variables
Special Variable, *testcase-supervisor-class*: Private special variables
stream-output: Private classes
success: Public structures
success-count: Private classes
success-p: Public classes

T
testcase-count: Private classes
total: Public structures
type: Public structures

W
width: Private classes
width: Private classes


A.4 Data types

Jump to:   A   C   F   K   M   P   R   S   T   U   V  
Index Entry  Section

A
assert.lisp: The kaputt/src/assert․lisp file
assertion: Public structures
assertion-failed: Private conditions

C
Class, pointless-supervisor: Private classes
Class, serviceable-supervisor: Private classes
Class, supervisor: Public classes
Class, tally-supervisor: Private classes
Class, trace-supervisor: Private classes
Class, verbose-supervisor: Private classes
Condition, assertion-failed: Private conditions
configuration.lisp: The kaputt/src/configuration․lisp file

F
File, assert.lisp: The kaputt/src/assert․lisp file
File, configuration.lisp: The kaputt/src/configuration․lisp file
File, kaputt.asd: The kaputt/kaputt․asd file
File, package.lisp: The kaputt/src/package․lisp file
File, result.lisp: The kaputt/src/result․lisp file
File, supervisor.lisp: The kaputt/src/supervisor․lisp file
File, testcase.lisp: The kaputt/src/testcase․lisp file
File, utilities.lisp: The kaputt/src/utilities․lisp file

K
kaputt: The kaputt system
kaputt: The kaputt package
kaputt.asd: The kaputt/kaputt․asd file

M
Module, src: The kaputt/src module

P
Package, kaputt: The kaputt package
package.lisp: The kaputt/src/package․lisp file
pointless-supervisor: Private classes

R
result.lisp: The kaputt/src/result․lisp file

S
serviceable-supervisor: Private classes
src: The kaputt/src module
Structure, assertion: Public structures
Structure, testcase: Public structures
supervisor: Public classes
supervisor.lisp: The kaputt/src/supervisor․lisp file
System, kaputt: The kaputt system

T
tally-supervisor: Private classes
testcase: Public structures
testcase.lisp: The kaputt/src/testcase․lisp file
trace-supervisor: Private classes

U
utilities.lisp: The kaputt/src/utilities․lisp file

V
verbose-supervisor: Private classes