The kaputt Reference Manual

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

• description (macro).
• string-match (function).

---

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

• assert-condition (macro).
• assert-eq (function).
• assert-eql (function).
• assert-equal (function).
• assert-float-is-approximately-equal (function).
• assert-float-is-definitely-greater-than (function).
• assert-float-is-definitely-less-than (function).
• assert-float-is-essentially-equal (function).
• assert-nil (function).
• assert-set-equal (function).
• assert-string-equal (function).
• assert-string< (function).
• assert-string<= (function).
• assert-string= (function).
• assert-string> (function).
• assert-string>= (function).
• assert-subsetp (function).
• assert-t (function).
• assert-t* (function).
• assert-type (function).
• assert-vector-equal (function).
• assert< (function).
• assert<= (function).
• assert= (function).
• assert> (function).
• assert>= (function).
• define-assertion (macro).

Internals

• *double-float-precision* (special variable).
• float-comparison-threshold (macro).
• report-string-comparison (function).
• report-string-comparison/details (function).
• report-string-comparison/unexpected-type (function).

---

4.1.6 kaputt/src/result.lisp

Source

kaputt.asd.

Parent Component

src (module).

Public Interface

• assertion (structure).
• assertion-arguments (reader).
• (setf assertion-arguments) (writer).
• assertion-condition (reader).
• (setf assertion-condition) (writer).
• assertion-description (reader).
• (setf assertion-description) (writer).
• assertion-form (reader).
• (setf assertion-form) (writer).
• assertion-name (reader).
• (setf assertion-name) (writer).
• assertion-outcome (reader).
• (setf assertion-outcome) (writer).
• assertion-p (function).
• assertion-path (reader).
• (setf assertion-path) (writer).
• assertion-type (reader).
• (setf assertion-type) (writer).
• make-assertion (function).
• make-testcase (function).
• testcase (structure).
• testcase-arguments (reader).
• (setf testcase-arguments) (writer).
• testcase-condition (reader).
• (setf testcase-condition) (writer).
• testcase-failure (reader).
• (setf testcase-failure) (writer).
• testcase-name (reader).
• (setf testcase-name) (writer).
• testcase-p (function).
• testcase-path (reader).
• (setf testcase-path) (writer).
• testcase-results (reader).
• (setf testcase-results) (writer).
• testcase-skip (reader).
• (setf testcase-skip) (writer).
• testcase-success (reader).
• (setf testcase-success) (writer).
• testcase-total (reader).
• (setf testcase-total) (writer).

Internals

• copy-assertion (function).
• copy-testcase (function).
• count-total-number-of-assertions (function).
• count-total-number-of-assertions-by-outcome (function).

---

4.1.7 kaputt/src/supervisor.lisp

Source

kaputt.asd.

Parent Component

src (module).

Public Interface

• supervisor (class).
• supervisor-assertion (generic function).
• supervisor-success-p (generic function).
• supervisor-testcase-begin (generic function).
• supervisor-testcase-end (generic function).

Internals

• *current-supervisor* (special variable).
• pointless-supervisor (class).
• serviceable-supervisor (class).
• supervisor-toplevel-begin (generic function).
• supervisor-toplevel-end (generic function).
• tally-supervisor (class).
• trace-supervisor (class).
• verbose-supervisor (class).

---

4.1.8 kaputt/src/testcase.lisp

Source

kaputt.asd.

Parent Component

src (module).

Public Interface

• assert-failure (macro).
• define-testcase (macro).
• testcase-batch (macro).
• testcase-continue (macro).
• testcase-ignore (macro).

Internals

• *testcase-interaction* (special variable).
• *testcase-path* (special variable).
• *testcase-results* (special variable).
• *testcase-skip* (special variable).
• *testcase-supervisor-class* (special variable).
• assert-failure/main (function).
• assert-failure/unexpected-condition (function).
• assertion-failed (condition).
• assertion-failed/report (function).
• define-testcase/wrap-assert-form (function).
• restart-assertion (macro).
• supervise-assertion (macro).

---

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

• supervisor-assertion.
• supervisor-success-p.
• supervisor-testcase-begin.
• supervisor-testcase-end.
• supervisor-toplevel-begin.
• supervisor-toplevel-end.

Direct slots

Slot: success-p ¶

Initform

t

---

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

• pointless-supervisor.
• serviceable-supervisor.

Direct methods

• supervisor-assertion.
• supervisor-testcase-begin.
• supervisor-toplevel-end.

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

• supervisor-assertion.
• supervisor-testcase-begin.
• supervisor-testcase-end.

Class: verbose-supervisor ¶

A verbose supervisor owns a STREAM-OUTPUT.

Package

kaputt.

Source

supervisor.lisp.

Direct superclasses

supervisor.

Direct subclasses

• tally-supervisor.
• trace-supervisor.

Direct slots

Slot: stream-output ¶

Initform

*standard-output*

---