The kaputt Reference Manual

Table of Contents

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

The kaputt Reference Manual

This is the kaputt Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Wed Nov 04 12:21:45 2020 GMT+0.


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

1 Introduction

Kaputt – A Simple Interactive Test Framework for Common Lisp

Kaputt is a test framework for Common Lisp that focuses on the following features:

See Comparison to some-other available test frameworks below for a more detailed motivation of the need for a new test framework.

Table of Contents

Installation

Quicklisp users

Kaputt is not yet available in the Quicklisp distribution, so Kaputt needs to be installed manually. Clone the repository in a directory listed in the ql:*local-project-directories* parameter and (ql:register-local-projects) so that you can (require "kaputt").

ASDF users

Clone the repository in a place where ASDF can find it, for instance ~/common-lisp if you are using a modern ASDF module with its default configuration. Then (require "kaputt").

Usage

This is illustrated by the file example.lisp from the distribution. We describe an interactive session based on the content of this file. After evaluating

(defpackage #:kaputt/example
  (:use #:common-lisp #:kaputt)
  (:export
   #:run-all-tests))

(in-package #:kaputt/example)

(define-testcase cl-strings/string-downcase-turns-nil-into-a-string ()
  (assert-string= "nil" (string-downcase nil)))

We can move to the REPL to evaluate:

CL-USER> (in-package #:kaputt/example)
#<PACKAGE "KAPUTT/EXAMPLE">

KAPUTT/EXAMPLE> (cl-strings/string-downcase-turns-nil-into-a-string)
.

Test suite ran 1 assertions split across 1 test cases.
 Success: 1/1 (100%)
 Failure: 0/1 (0%)

T

Let's define a few more tests by evaluating a further form from example.lisp but we modify it to display how Kaputt handles failing assertions:

(define-testcase cl-strings/string-upcase-turns-nil-into-a-string ()
  (assert-string= "nil" (string-upcase nil)))

The evaluation of the function

KAPUTT/EXAMPLE> (cl-strings/string-upcase-turns-nil-into-a-string)

summons the debugger:

Test assertion failed:

  (ASSERT-STRING= "nil" (STRING-UPCASE NIL))

In this call, the composed forms in argument position evaluate as:

  (STRING-UPCASE NIL) => "NIL"

The assertion ASSERT-STRING= is defined by the body forms

  (STRING= STRING1 STRING2 :START1 START1 :END1 END1 :START2 START2 :END2 END2)

It has no high-level description.
   [Condition of type KAPUTT::ASSERTION-FAILED]

Restarts:
 0: [CONTINUE] Record a failure for ASSERT-STRING= and continue testing.
 1: [IGNORE] Record a success for ASSERT-STRING= and continue testing.
 2: [RETRY] Retry ASSERT-STRING=.
 3: [SKIP] Skip the rest of test case CL-STRINGS/STRING-UPCASE-TURNS-NIL-INTO-A-STRING and continue testing.
 4: [RETRY] Retry SLIME REPL evaluation request.
 5: [*ABORT] Return to SLIME's top level.
 --more--

We can fix the testcase by formulating a reasonable expectation:

(define-testcase cl-strings/string-upcase-turns-nil-into-a-string ()
  (assert-string= "NIL" (string-upcase nil)))

and 4. [RETRY] the SLIME REPL evaluation request to see the tests complete. The report describing the error condition met by the failing assertion can be customised freely when defining a new assertion.

We can finally organise our tests in a testsuite by defining a test case calling other test cases:

(define-testcase run-all-tests ()
  (cl-strings/string-downcase-turns-nil-into-a-string)
  (cl-strings/string-upcase-turns-nil-into-a-string))

It is possible to define parametrised testcases. See in kaputt.lisp various example of advanced usages of the define-assertion function.

Defining an ASDF system depending on Kaputt

This snippets show an example of ASF system definition for a systeme depending on Kaputt:

(asdf:defsystem #:kaputt/example
  :description "An Example for the Kaputt Test Framework"
  :author "Michaël Le Barbier"
  :license "MIT"
  :depends-on (#:kaputt)
  :components
  ((:file "example")))

Comparison to some other available test frameworks

Before writing Kaputt I worked with Stefil and FiveAM which in my experience were:

Not simple

These other test frameworks make provision to organise tests hierarchically in test suites. In Kaputt a test case is also a normal Lisp function and test suites can be modelled by test cases calling several test cases or test suites in sequence. There is no need for specific support in the test framework to define this hierarchical organisation.

These other test frameworks make provision to define test fixtures (test setup and tearoff). In Kaputt since a test case is also a function, the usual WITH-* idiom can be used to define test fixtures and therefore the test framework does not need to define specific support for these.

Not extensible

These other test frameworks are built around an IS macro which is presented as a generic “do what I mean” comparison operator. I found this not convenient to use in specific situations, e.g. when testing numerical algorithms and was very unsatisified with the kludges and workarounds I needed to build to still use the IS macro and found the resulting code rather convoluted and uninformative.

In Kaputt tests are built around assertions and new assertions can be defined with the DEFINE-ASSERTION macro.

Not fitting well interactive development

These other frameworks using the “do what I mean” comparison approach were not showing me the information I needed to make a first diagnostic of error conditions met and I spent a lot of time evaluating various expressions in the more-or-less right backtrace frame.

In Kaputt we have total control of the report produced by the error condition triggered by error failures, so that reports are much more informative and lead to quicker error r


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

2 Systems

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


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

2.1 kaputt

Author

Michaël Le Barbier

Home Page

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

License

MIT

Description

A Simple Interactive Test Framework for Common Lisp

Source

kaputt.asd (file)

Component

kaputt.lisp (file)


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

3 Files

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


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

3.1 Lisp


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

3.1.1 kaputt.asd

Location

kaputt.asd

Systems

kaputt (system)


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

3.1.2 kaputt/kaputt.lisp

Parent

kaputt (system)

Location

kaputt.lisp

Packages

kaputt

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 kaputt

The Kaputt Test Framework.

Source

kaputt.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *testcase-protocol-class*

The protocol class to use when running test suites.

Package

kaputt

Source

kaputt.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: define-assertion ASSERTION-NAME ASSERTION-ARGS &body BODY

Define an assertion function ASSERTION-NAME, accepting ASSERTION-ARGS with BODY.

The BODY is interpreted as computing a generalised boolean value,
which triggers an ASSERTION-FAILED when this boolean is NIL.

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

kaputt.lisp (file)

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

Test cases are allowed to be nested. A toplevel test case is a test suite and triggers testsuite protocol 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

kaputt.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 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

kaputt.lisp (file)

Function: assert-eql A B

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

Package

kaputt

Source

kaputt.lisp (file)

Function: assert-equal A B

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

Package

kaputt

Source

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

Function: assert-nil EXPR

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

Package

kaputt

Source

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

Function: assert-t EXPR

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

Package

kaputt

Source

kaputt.lisp (file)

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

kaputt.lisp (file)

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

kaputt.lisp (file)

Function: assert< A B

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

Package

kaputt

Source

kaputt.lisp (file)

Function: assert<= A B

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

Package

kaputt

Source

kaputt.lisp (file)

Function: assert= A B

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

Package

kaputt

Source

kaputt.lisp (file)

Function: assert> A B

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

Package

kaputt

Source

kaputt.lisp (file)

Function: assert>= A B

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

Package

kaputt

Source

kaputt.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Generic functions

Generic Function: protocol-assertion-begin PROTOCOL ASSERTION ARGUMENTS

This event is sent to a protocol when an assertion begins.

Package

kaputt

Source

kaputt.lisp (file)

Method Combination

progn (short method combination)

Options: :most-specific-first

Methods
Method: protocol-assertion-begin (P protocol-record) ASSERTION ARGUMENTS progn
Method: protocol-assertion-begin (P protocol-count) ASSERTION ARGUMENTS progn
Method: protocol-assertion-begin (P protocol-trace) ASSERTION ARGUMENTS progn
Method: protocol-assertion-begin (P null) ASSERTION ARGUMENTS progn
Method: protocol-assertion-begin (P protocol) ASSERTION ARGUMENTS progn
Generic Function: protocol-assertion-end PROTOCOL ASSERTION OUTCOME

This event is sent to a protocol when an assertion ends.

Package

kaputt

Source

kaputt.lisp (file)

Method Combination

progn (short method combination)

Options: :most-specific-first

Methods
Method: protocol-assertion-end (P protocol-dotta) ASSERTION OUTCOME progn
Method: protocol-assertion-end (P protocol-record) ASSERTION OUTCOME progn
Method: protocol-assertion-end (P protocol-count) ASSERTION OUTCOME progn
Method: protocol-assertion-end (P protocol-trace) ASSERTION OUTCOME progn
Method: protocol-assertion-end (P null) ASSERTION OUTCOME progn
Method: protocol-assertion-end (P protocol) ASSERTION OUTCOME progn
Generic Function: protocol-success-p PROTOCOL

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

Package

kaputt

Source

kaputt.lisp (file)

Methods
Method: protocol-success-p (P null)
Method: protocol-success-p (P protocol)
Generic Function: protocol-testcase-begin PROTOCOL TESTCASE

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

Package

kaputt

Source

kaputt.lisp (file)

Method Combination

progn (short method combination)

Options: :most-specific-first

Methods
Method: protocol-testcase-begin (P protocol-record) TESTCASE progn
Method: protocol-testcase-begin (P protocol-count) TESTCASE progn
Method: protocol-testcase-begin (P protocol-trace) TESTCASE progn
Method: protocol-testcase-begin (P null) TESTCASE progn
Method: protocol-testcase-begin (P protocol) TESTCASE progn
Generic Function: protocol-testcase-end PROTOCOL TESTCASE OUTCOME

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

Package

kaputt

Source

kaputt.lisp (file)

Method Combination

progn (short method combination)

Options: :most-specific-first

Methods
Method: protocol-testcase-end (P protocol-trace) TESTCASE OUTCOME progn
Method: protocol-testcase-end (P null) TESTCASE OUTCOME progn
Method: protocol-testcase-end (P protocol) TESTCASE OUTCOME progn
Generic Function: protocol-testsuite-begin PROTOCOL

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

Package

kaputt

Source

kaputt.lisp (file)

Method Combination

progn (short method combination)

Options: :most-specific-first

Methods
Method: protocol-testsuite-begin (P null) progn
Method: protocol-testsuite-begin (P protocol) progn
Generic Function: protocol-testsuite-end PROTOCOL

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

Package

kaputt

Source

kaputt.lisp (file)

Method Combination

progn (short method combination)

Options: :most-specific-first

Methods
Method: protocol-testsuite-end (P protocol-dotta) progn
Method: protocol-testsuite-end (P protocol-record) progn
Method: protocol-testsuite-end (P null) progn
Method: protocol-testsuite-end (P protocol) progn

Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Classes

Class: protocol ()

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

Descendants of this class provide more functionalities.

Package

kaputt

Source

kaputt.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: success-p
Initform

t

Slot: batch-p
Initform

kaputt::*batch-mode*

Class: protocol-count ()

A count protocol counts TESTCASE, ASSERTION, SUCCESS and FAILURE.

Package

kaputt

Source

kaputt.lisp (file)

Direct superclasses

protocol (class)

Direct subclasses

protocol-dotta (class)

Direct methods
Direct slots
Slot: testcase-count
Initform

0

Slot: assertion-count
Initform

0

Slot: success-count
Initform

0

Slot: failure-count
Initform

0

Class: protocol-dotta ()

A dotta protocol 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

kaputt.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: width
Initform

70

Class: protocol-record ()

A protocol record keeps track of all failures encountered in a test suite and prints a detailed list of the failures when the test suite finishes.

Package

kaputt

Source

kaputt.lisp (file)

Direct superclasses

protocol-verbose (class)

Direct subclasses

protocol-dotta (class)

Direct methods
Direct slots
Slot: current-testcase
Slot: current-assertion
Slot: failure-list
Class: protocol-trace ()

A trace protocol reports each event sent to it.

Package

kaputt

Source

kaputt.lisp (file)

Direct superclasses

protocol-verbose (class)

Direct methods
Class: protocol-verbose ()

A verbose protocol owns a STREAM-OUTPUT.

Package

kaputt

Source

kaputt.lisp (file)

Direct superclasses

protocol (class)

Direct subclasses
Direct slots
Slot: stream-output
Initform

*standard-output*


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

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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

kaputt.lisp (file)

Special Variable: *current-protocol*

The current protocol.

Package

kaputt

Source

kaputt.lisp (file)

Special Variable: *double-float-precision*
Package

kaputt

Source

kaputt.lisp (file)

Special Variable: *testcase-assertion-args*

The list of argument values used to call the current assertion in a test case.

Package

kaputt

Source

kaputt.lisp (file)

Special Variable: *testcase-assertion-form*

The form used to call the current assertion in a test case.

Package

kaputt

Source

kaputt.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: float-comparison-threshold BINOP K U V
Package

kaputt

Source

kaputt.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: define-testcase/wrap-assert-form BODY-FORMS

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

Package

kaputt

Source

kaputt.lisp (file)

Function: report-string-comparison COMPARISON STRING1 STRING2
Package

kaputt

Source

kaputt.lisp (file)

Function: report-string-comparison/details STREAM COMPARISON STRING1 STRING2
Package

kaputt

Source

kaputt.lisp (file)

Function: report-string-comparison/unexpected-type STREAM LABEL OBJECT
Package

kaputt

Source

kaputt.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Generic functions

Generic Function: assertion-args CONDITION
Generic Function: (setf assertion-args) NEW-VALUE CONDITION
Package

kaputt

Methods
Method: assertion-args (CONDITION assertion-failed)
Method: (setf assertion-args) NEW-VALUE (CONDITION assertion-failed)
Source

kaputt.lisp (file)

Generic Function: assertion-description CONDITION
Generic Function: (setf assertion-description) NEW-VALUE CONDITION
Package

kaputt

Methods
Method: assertion-description (CONDITION assertion-failed)
Method: (setf assertion-description) NEW-VALUE (CONDITION assertion-failed)
Source

kaputt.lisp (file)

Generic Function: assertion-form CONDITION
Generic Function: (setf assertion-form) NEW-VALUE CONDITION
Package

kaputt

Methods
Method: assertion-form (CONDITION assertion-failed)
Method: (setf assertion-form) NEW-VALUE (CONDITION assertion-failed)
Source

kaputt.lisp (file)

Generic Function: protocol-batch-p PROTOCOL

This method tells if a test suite is in batch mode.

Package

kaputt

Source

kaputt.lisp (file)

Methods
Method: protocol-batch-p (P null)
Method: protocol-batch-p (P protocol)
Generic Function: protocol-enable-batch-mode PROTOCOL

This method enables batch mode for a test suite.

Package

kaputt

Source

kaputt.lisp (file)

Methods
Method: protocol-enable-batch-mode (P null)
Method: protocol-enable-batch-mode (P protocol)

Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Conditions

Condition: assertion-failed ()
Package

kaputt

Source

kaputt.lisp (file)

Direct superclasses

serious-condition (condition)

Direct methods
Direct slots
Slot: assertion-description
Initargs

:assertion-description

Readers

assertion-description (generic function)

Writers

(setf assertion-description) (generic function)

Slot: assertion-form
Initargs

:assertion-form

Readers

assertion-form (generic function)

Writers

(setf assertion-form) (generic function)

Slot: assertion-args
Initargs

:assertion-args

Readers

assertion-args (generic function)

Writers

(setf assertion-args) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   K   L  
Index Entry  Section

F
File, Lisp, kaputt.asd: The kaputt․asd file
File, Lisp, kaputt/kaputt.lisp: The kaputt/kaputt․lisp file

K
kaputt.asd: The kaputt․asd file
kaputt/kaputt.lisp: The kaputt/kaputt․lisp file

L
Lisp File, kaputt.asd: The kaputt․asd file
Lisp File, kaputt/kaputt.lisp: The kaputt/kaputt․lisp file

Jump to:   F   K   L  

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

A.2 Functions

Jump to:   (  
A   D   F   G   M   P   R  
Index Entry  Section

(
(setf assertion-args): Internal generic functions
(setf assertion-args): Internal generic functions
(setf assertion-description): Internal generic functions
(setf assertion-description): Internal generic functions
(setf assertion-form): Internal generic functions
(setf assertion-form): Internal generic functions

A
assert-eq: Exported functions
assert-eql: Exported functions
assert-equal: Exported functions
assert-float-is-approximately-equal: Exported functions
assert-float-is-definitely-greater-than: Exported functions
assert-float-is-definitely-less-than: Exported functions
assert-float-is-essentially-equal: Exported functions
assert-nil: Exported functions
assert-set-equal: Exported functions
assert-string-equal: Exported functions
assert-string<: Exported functions
assert-string<=: Exported functions
assert-string=: Exported functions
assert-string>: Exported functions
assert-string>=: Exported functions
assert-subsetp: Exported functions
assert-t: Exported functions
assert-type: Exported functions
assert-vector-equal: Exported functions
assert<: Exported functions
assert<=: Exported functions
assert=: Exported functions
assert>: Exported functions
assert>=: Exported functions
assertion-args: Internal generic functions
assertion-args: Internal generic functions
assertion-description: Internal generic functions
assertion-description: Internal generic functions
assertion-form: Internal generic functions
assertion-form: Internal generic functions

D
define-assertion: Exported macros
define-testcase: Exported macros
define-testcase/wrap-assert-form: Internal functions

F
float-comparison-threshold: Internal macros
Function, assert-eq: Exported functions
Function, assert-eql: Exported functions
Function, assert-equal: Exported functions
Function, assert-float-is-approximately-equal: Exported functions
Function, assert-float-is-definitely-greater-than: Exported functions
Function, assert-float-is-definitely-less-than: Exported functions
Function, assert-float-is-essentially-equal: Exported functions
Function, assert-nil: Exported functions
Function, assert-set-equal: Exported functions
Function, assert-string-equal: Exported functions
Function, assert-string<: Exported functions
Function, assert-string<=: Exported functions
Function, assert-string=: Exported functions
Function, assert-string>: Exported functions
Function, assert-string>=: Exported functions
Function, assert-subsetp: Exported functions
Function, assert-t: Exported functions
Function, assert-type: Exported functions
Function, assert-vector-equal: Exported functions
Function, assert<: Exported functions
Function, assert<=: Exported functions
Function, assert=: Exported functions
Function, assert>: Exported functions
Function, assert>=: Exported functions
Function, define-testcase/wrap-assert-form: Internal functions
Function, report-string-comparison: Internal functions
Function, report-string-comparison/details: Internal functions
Function, report-string-comparison/unexpected-type: Internal functions

G
Generic Function, (setf assertion-args): Internal generic functions
Generic Function, (setf assertion-description): Internal generic functions
Generic Function, (setf assertion-form): Internal generic functions
Generic Function, assertion-args: Internal generic functions
Generic Function, assertion-description: Internal generic functions
Generic Function, assertion-form: Internal generic functions
Generic Function, protocol-assertion-begin: Exported generic functions
Generic Function, protocol-assertion-end: Exported generic functions
Generic Function, protocol-batch-p: Internal generic functions
Generic Function, protocol-enable-batch-mode: Internal generic functions
Generic Function, protocol-success-p: Exported generic functions
Generic Function, protocol-testcase-begin: Exported generic functions
Generic Function, protocol-testcase-end: Exported generic functions
Generic Function, protocol-testsuite-begin: Exported generic functions
Generic Function, protocol-testsuite-end: Exported generic functions

M
Macro, define-assertion: Exported macros
Macro, define-testcase: Exported macros
Macro, float-comparison-threshold: Internal macros
Method, (setf assertion-args): Internal generic functions
Method, (setf assertion-description): Internal generic functions
Method, (setf assertion-form): Internal generic functions
Method, assertion-args: Internal generic functions
Method, assertion-description: Internal generic functions
Method, assertion-form: Internal generic functions
Method, protocol-assertion-begin: Exported generic functions
Method, protocol-assertion-begin: Exported generic functions
Method, protocol-assertion-begin: Exported generic functions
Method, protocol-assertion-begin: Exported generic functions
Method, protocol-assertion-begin: Exported generic functions
Method, protocol-assertion-end: Exported generic functions
Method, protocol-assertion-end: Exported generic functions
Method, protocol-assertion-end: Exported generic functions
Method, protocol-assertion-end: Exported generic functions
Method, protocol-assertion-end: Exported generic functions
Method, protocol-assertion-end: Exported generic functions
Method, protocol-batch-p: Internal generic functions
Method, protocol-batch-p: Internal generic functions
Method, protocol-enable-batch-mode: Internal generic functions
Method, protocol-enable-batch-mode: Internal generic functions
Method, protocol-success-p: Exported generic functions
Method, protocol-success-p: Exported generic functions
Method, protocol-testcase-begin: Exported generic functions
Method, protocol-testcase-begin: Exported generic functions
Method, protocol-testcase-begin: Exported generic functions
Method, protocol-testcase-begin: Exported generic functions
Method, protocol-testcase-begin: Exported generic functions
Method, protocol-testcase-end: Exported generic functions
Method, protocol-testcase-end: Exported generic functions
Method, protocol-testcase-end: Exported generic functions
Method, protocol-testsuite-begin: Exported generic functions
Method, protocol-testsuite-begin: Exported generic functions
Method, protocol-testsuite-end: Exported generic functions
Method, protocol-testsuite-end: Exported generic functions
Method, protocol-testsuite-end: Exported generic functions
Method, protocol-testsuite-end: Exported generic functions

P
protocol-assertion-begin: Exported generic functions
protocol-assertion-begin: Exported generic functions
protocol-assertion-begin: Exported generic functions
protocol-assertion-begin: Exported generic functions
protocol-assertion-begin: Exported generic functions
protocol-assertion-begin: Exported generic functions
protocol-assertion-end: Exported generic functions
protocol-assertion-end: Exported generic functions
protocol-assertion-end: Exported generic functions
protocol-assertion-end: Exported generic functions
protocol-assertion-end: Exported generic functions
protocol-assertion-end: Exported generic functions
protocol-assertion-end: Exported generic functions
protocol-batch-p: Internal generic functions
protocol-batch-p: Internal generic functions
protocol-batch-p: Internal generic functions
protocol-enable-batch-mode: Internal generic functions
protocol-enable-batch-mode: Internal generic functions
protocol-enable-batch-mode: Internal generic functions
protocol-success-p: Exported generic functions
protocol-success-p: Exported generic functions
protocol-success-p: Exported generic functions
protocol-testcase-begin: Exported generic functions
protocol-testcase-begin: Exported generic functions
protocol-testcase-begin: Exported generic functions
protocol-testcase-begin: Exported generic functions
protocol-testcase-begin: Exported generic functions
protocol-testcase-begin: Exported generic functions
protocol-testcase-end: Exported generic functions
protocol-testcase-end: Exported generic functions
protocol-testcase-end: Exported generic functions
protocol-testcase-end: Exported generic functions
protocol-testsuite-begin: Exported generic functions
protocol-testsuite-begin: Exported generic functions
protocol-testsuite-begin: Exported generic functions
protocol-testsuite-end: Exported generic functions
protocol-testsuite-end: Exported generic functions
protocol-testsuite-end: Exported generic functions
protocol-testsuite-end: Exported generic functions
protocol-testsuite-end: Exported generic functions

R
report-string-comparison: Internal functions
report-string-comparison/details: Internal functions
report-string-comparison/unexpected-type: Internal functions

Jump to:   (  
A   D   F   G   M   P   R  

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

A.3 Variables

Jump to:   *  
A   B   C   F   S   T   W  
Index Entry  Section

*
*batch-mode*: Internal special variables
*current-protocol*: Internal special variables
*double-float-precision*: Internal special variables
*testcase-assertion-args*: Internal special variables
*testcase-assertion-form*: Internal special variables
*testcase-protocol-class*: Exported special variables

A
assertion-args: Internal conditions
assertion-count: Exported classes
assertion-description: Internal conditions
assertion-form: Internal conditions

B
batch-p: Exported classes

C
current-assertion: Exported classes
current-testcase: Exported classes

F
failure-count: Exported classes
failure-list: Exported classes

S
Slot, assertion-args: Internal conditions
Slot, assertion-count: Exported classes
Slot, assertion-description: Internal conditions
Slot, assertion-form: Internal conditions
Slot, batch-p: Exported classes
Slot, current-assertion: Exported classes
Slot, current-testcase: Exported classes
Slot, failure-count: Exported classes
Slot, failure-list: Exported classes
Slot, stream-output: Exported classes
Slot, success-count: Exported classes
Slot, success-p: Exported classes
Slot, testcase-count: Exported classes
Slot, width: Exported classes
Special Variable, *batch-mode*: Internal special variables
Special Variable, *current-protocol*: Internal special variables
Special Variable, *double-float-precision*: Internal special variables
Special Variable, *testcase-assertion-args*: Internal special variables
Special Variable, *testcase-assertion-form*: Internal special variables
Special Variable, *testcase-protocol-class*: Exported special variables
stream-output: Exported classes
success-count: Exported classes
success-p: Exported classes

T
testcase-count: Exported classes

W
width: Exported classes

Jump to:   *  
A   B   C   F   S   T   W  

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

A.4 Data types

Jump to:   A   C   K   P   S  
Index Entry  Section

A
assertion-failed: Internal conditions

C
Class, protocol: Exported classes
Class, protocol-count: Exported classes
Class, protocol-dotta: Exported classes
Class, protocol-record: Exported classes
Class, protocol-trace: Exported classes
Class, protocol-verbose: Exported classes
Condition, assertion-failed: Internal conditions

K
kaputt: The kaputt system
kaputt: The kaputt package

P
Package, kaputt: The kaputt package
protocol: Exported classes
protocol-count: Exported classes
protocol-dotta: Exported classes
protocol-record: Exported classes
protocol-trace: Exported classes
protocol-verbose: Exported classes

S
System, kaputt: The kaputt system

Jump to:   A   C   K   P   S