The eos Reference Manual

This is the eos Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 16:21:38 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 eos

UNMAINTAINED fork of 5AM, a test framework

Author

Adlai Chandrasekhar

License

MIT

Source

eos.asd.

Child Component

src (module).


3 Modules

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


3.1 eos/src

Source

eos.asd.

Parent Component

eos (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 eos/eos.asd

Source

eos.asd.

Parent Component

eos (system).

ASDF Systems

eos.


4.1.2 eos/src/package.lisp

Source

eos.asd.

Parent Component

src (module).

Packages

eos.


4.1.3 eos/src/utils.lisp

Dependency

package.lisp (file).

Source

eos.asd.

Parent Component

src (module).

Internals

4.1.4 eos/src/classes.lisp

Dependency

package.lisp (file).

Source

eos.asd.

Parent Component

src (module).

Public Interface

print-object (method).

Internals

4.1.5 eos/src/check.lisp

Dependency

utils.lisp (file).

Source

eos.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.6 eos/src/test.lisp

Dependency

classes.lisp (file).

Source

eos.asd.

Parent Component

src (module).

Public Interface
Internals

*test* (special variable).


4.1.7 eos/src/explain.lisp

Dependencies
Source

eos.asd.

Parent Component

src (module).

Public Interface
Internals

partition-results (function).


4.1.8 eos/src/suite.lisp

Dependencies
Source

eos.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.9 eos/src/run.lisp

Dependencies
Source

eos.asd.

Parent Component

src (module).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


5.1 eos

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

Special Variable: *debug-on-error*

T if we should drop into a debugger on error, NIL otherwise.

Package

eos.

Source

run.lisp.

Special Variable: *debug-on-failure*

T if we should drop into a debugger on a failing check, NIL otherwise.

Package

eos.

Source

run.lisp.

Special Variable: *run-test-when-defined*

When non-NIL tests are run as soon as they are defined.

Package

eos.

Source

test.lisp.

Special Variable: *test-dribble*
Package

eos.

Source

check.lisp.

Special Variable: *verbose-failures*

T if we should print the expression failing, NIL otherwise.

Package

eos.

Source

explain.lisp.


6.1.2 Macros

Macro: def-suite (name &key description in)

Define a new test-suite named NAME.

IN (a symbol), if provided, causes this suite te be nested in the suite named by IN. NB: This macro is built on top of make-suite, as such it, like make-suite, will overrwrite any existing suite named NAME.

Package

eos.

Source

suite.lisp.

Macro: fail (&rest message-args)

Simply generate a FAIL.

Package

eos.

Source

check.lisp.

Macro: finishes (&body body)

Generates a pass if BODY executes to normal completion. In other words if body does signal, return-from or throw this test fails.

Package

eos.

Source

check.lisp.

Macro: in-suite (suite-name)

Set the *suite* special variable so that all tests defined after the execution of this form are, unless specified otherwise, in the test-suite named SUITE-NAME.

See also: DEF-SUITE *SUITE*

Package

eos.

Source

suite.lisp.

Macro: in-suite* (suite-name &key in)

Just like in-suite, but silently creates missing suites.

Package

eos.

Source

suite.lisp.

Macro: is (test &rest reason-args)

The DWIM checking operator.

If TEST returns a true value a test-passed result is generated, otherwise a test-failure result is generated. The reason, unless REASON-ARGS is provided, is generated based on the form of TEST:

(predicate expected actual) - Means that we want to check whether, according to PREDICATE, the ACTUAL value is
in fact what we EXPECTED.

(predicate value) - Means that we want to ensure that VALUE satisfies PREDICATE.

Wrapping the TEST form in a NOT simply preducse a negated reason string.

Package

eos.

Source

check.lisp.

Macro: is-false (condition &rest reason-args)

Generates a pass if CONDITION returns false, generates a failure otherwise. Like IS-TRUE, and unlike IS, IS-FALSE does not inspect CONDITION to determine what reason to give it case of test failure

Package

eos.

Source

check.lisp.

Macro: is-true (condition &rest reason-args)

Like IS this check generates a pass if CONDITION returns true and a failure if CONDITION returns false. Unlike IS this check does not inspect CONDITION to determine how to report the failure.

Package

eos.

Source

check.lisp.

Macro: pass (&rest message-args)

Simply generate a PASS.

Package

eos.

Source

check.lisp.

Macro: signals (condition-spec &body body)

Generates a pass if BODY signals a condition of type CONDITION. BODY is evaluated in a block named NIL, CONDITION is not evaluated.

Package

eos.

Source

check.lisp.

Macro: skip (&rest reason)

Generates a TEST-SKIPPED result.

Package

eos.

Source

check.lisp.

Macro: test (name &body body)

Create a test named NAME. If NAME is a list it must be of the form:

(name &key depends-on suite fixture compile-at)

NAME is the symbol which names the test.

DEPENDS-ON is a list of the form:

(AND . test-names) - This test is run only if all of the tests in TEST-NAMES have passed, otherwise a single test-skipped result is generated.

(OR . test-names) - If any of TEST-NAMES has passed this test is run, otherwise a test-skipped result is generated.

(NOT test-name) - This is test is run only if TEST-NAME failed.

AND, OR and NOT can be combined to produce complex dependencies.

If DEPENDS-ON is a symbol it is interpreted as ‘(AND ,depends-on), this is accomadate the common case of one test depending on another.

FIXTURE specifies a fixtrue to wrap the body in.

Package

eos.

Source

test.lisp.


6.1.3 Ordinary functions

Function: ! ()

Rerun the most recently run test and explain the results.

Package

eos.

Source

run.lisp.

Function: !! ()

Rerun the second most recently run test and explain the results.

Package

eos.

Source

run.lisp.

Function: !!! ()

Rerun the third most recently run test and explain the results.

Package

eos.

Source

run.lisp.

Function: debug! (&optional test-spec)

Calls (run! test-spec) but enters the debugger if any kind of error happens.

Package

eos.

Source

run.lisp.

Function: explain! (result-list)

Explain the results of RESULT-LIST using a detailed-text-explainer with output going to *test-dribble*

Package

eos.

Source

run.lisp.

Function: get-test (key &optional default)
Package

eos.

Source

test.lisp.

Function: (setf get-test) (key)
Package

eos.

Source

test.lisp.

Function: make-suite (name &key description in)

Create a new test suite object.

Overides any existing suite named NAME.

Package

eos.

Source

suite.lisp.

Function: rem-test (key)
Package

eos.

Source

test.lisp.

Function: results-status (result-list)

Given a list of test results (generated while running a test) return true if all of the results are of type TEST-PASSED, faile otherwise.

Package

eos.

Source

run.lisp.

Function: run (test-spec)

Run the test specified by TEST-SPEC.

TEST-SPEC can be either a symbol naming a test or test suite, or a testable-object object. This function changes the operations performed by the !, !! and !!! functions.

Package

eos.

Source

run.lisp.

Function: run! (&optional test-spec)

Equivalent to (explain (run TEST-SPEC)).

Package

eos.

Source

run.lisp.

Function: test-names ()
Package

eos.

Source

test.lisp.


6.1.4 Generic functions

Generic Function: explain (explainer results &optional stream recursive-depth)
Package

eos.

Source

explain.lisp.

Methods
Method: explain ((exp detailed-text-explainer) results &optional stream recursive-depth)
Method: explain ((exp simple-text-explainer) results &optional stream recursive-depth)

6.1.5 Standalone methods

Method: print-object ((test testable-object) stream)
Source

classes.lisp.


6.2 Internals


6.2.1 Special variables

Special Variable: *!!!*
Package

eos.

Source

run.lisp.

Special Variable: *!!*
Package

eos.

Source

run.lisp.

Special Variable: *!*
Package

eos.

Source

run.lisp.

Special Variable: *initial-!*
Package

eos.

Source

run.lisp.

Special Variable: *run-queue*

List of test waiting to be run.

Package

eos.

Source

run.lisp.

Special Variable: *suite*

The current test suite object

Package

eos.

Source

suite.lisp.

Special Variable: *test*

Table containing all test and test suite objects.

Package

eos.

Source

test.lisp.


6.2.2 Macros

Macro: %in-suite (suite-name &key fail-on-error in)
Package

eos.

Source

suite.lisp.

Macro: acond2 (&rest clauses)
Package

eos.

Source

utils.lisp.

Macro: aif (test true &optional false)
Package

eos.

Source

utils.lisp.

Macro: bind-run-state (requested-vars &body body)
Package

eos.

Source

check.lisp.

Macro: collect (names &body body)
Package

eos.

Source

utils.lisp.

Macro: def-suite* (name &rest def-suite-args)
Package

eos.

Source

suite.lisp.

Macro: fun (&body body)
Package

eos.

Source

utils.lisp.

Macro: list-match-case (target &body clauses)
Package

eos.

Source

utils.lisp.

Macro: process-failure (&rest args)
Package

eos.

Source

check.lisp.

Macro: with-*test-dribble* (stream &body body)
Package

eos.

Source

check.lisp.

Macro: with-gensyms ((&rest syms) &body body)

This is a simple WITH-GENSYMS, similar to the one presented in PCL.

Package

eos.

Source

utils.lisp.

Macro: with-run-state (requested-vars &body body)
Package

eos.

Source

check.lisp.


6.2.3 Ordinary functions

Function: add-result (result-type &rest make-instance-args)

Create a TEST-RESULT object of type RESULT-TYPE passing it the initialize args MAKE-INSTANCE-ARGS and adds the resulting object to the list of test results.

Package

eos.

Source

check.lisp.

Function: binding (x binds)
Package

eos.

Source

utils.lisp.

Function: ensure-list (x)
Package

eos.

Source

utils.lisp.

Function: find-vars (spec acc)
Package

eos.

Source

utils.lisp.

Function: import-testing-symbols (package-designator)
Package

eos.

Source

run.lisp.

Function: list-match (x y &optional binds)
Package

eos.

Source

utils.lisp.

Function: partition-results (results-list)
Package

eos.

Source

explain.lisp.

Function: return-result-list (test-lambda)

Run the test function TEST-LAMBDA and return a list of all test results generated, does not modify the special environment variable RESULT-LIST.

Package

eos.

Source

run.lisp.

Function: varsymp (x)
Package

eos.

Source

utils.lisp.


6.2.4 Generic functions

Generic Function: %run (test-spec)

Internal method for running a test. Does not update
the status of the tests nor the special vairables !, !!, or !!!

Package

eos.

Source

run.lisp.

Methods
Method: %run ((test test-case))
Method: %run ((tests list))
Method: %run ((suite test-suite))
Method: %run ((test-name symbol))
Generic Reader: actual-condition (object)
Package

eos.

Methods
Reader Method: actual-condition ((unexpected-test-failure unexpected-test-failure))

automatically generated reader method

Source

check.lisp.

Target Slot

actual-condition.

Generic Writer: (setf actual-condition) (object)
Package

eos.

Methods
Writer Method: (setf actual-condition) ((unexpected-test-failure unexpected-test-failure))

automatically generated writer method

Source

check.lisp.

Target Slot

actual-condition.

Generic Reader: depends-on (object)
Generic Writer: (setf depends-on) (object)
Package

eos.

Methods
Reader Method: depends-on ((testable-object testable-object))
Writer Method: (setf depends-on) ((testable-object testable-object))

The list of AND, OR, NOT forms specifying when to run this test.

Source

classes.lisp.

Target Slot

depends-on.

Generic Reader: description (object)
Generic Writer: (setf description) (object)
Package

eos.

Methods
Reader Method: description ((testable-object testable-object))
Writer Method: (setf description) ((testable-object testable-object))

The textual description of this test object.

Source

classes.lisp.

Target Slot

description.

Generic Reader: name (object)
Generic Writer: (setf name) (object)
Package

eos.

Methods
Reader Method: name ((testable-object testable-object))
Writer Method: (setf name) ((testable-object testable-object))

A symbol naming this test object.

Source

classes.lisp.

Target Slot

name.

Generic Reader: reason (object)
Package

eos.

Methods
Reader Method: reason ((condition check-failure))
Source

check.lisp.

Target Slot

reason.

Reader Method: reason ((test-result test-result))

automatically generated reader method

Source

check.lisp.

Target Slot

reason.

Generic Writer: (setf reason) (object)
Package

eos.

Methods
Writer Method: (setf reason) ((condition check-failure))
Source

check.lisp.

Target Slot

reason.

Writer Method: (setf reason) ((test-result test-result))

automatically generated writer method

Source

check.lisp.

Target Slot

reason.

Generic Function: resolve-dependencies (depends-on)
Package

eos.

Source

run.lisp.

Methods
Method: resolve-dependencies ((depends-on symbol))

A test which depends on a symbol is interpreted as ‘(AND ,DEPENDS-ON).

Method: resolve-dependencies ((depends-on list))

Return true if the dependency spec DEPENDS-ON is satisfied,nil otherwise.

Generic Function: run-resolving-dependencies (test)

Given a dependency spec determine if the spec is
satisfied or not, this will generally involve running other tests. If the dependency spec can be satisfied the test is also run.

Package

eos.

Source

run.lisp.

Methods
Method: run-resolving-dependencies ((test test-case))

Return true if this test, and its dependencies, are satisfied, NIL otherwise.

Generic Function: run-test-lambda (test)
Package

eos.

Source

run.lisp.

Methods
Method: run-test-lambda ((test test-case))
Generic Reader: runtime-package (object)
Generic Writer: (setf runtime-package) (object)
Package

eos.

Methods
Reader Method: runtime-package ((test-case test-case))
Writer Method: (setf runtime-package) ((test-case test-case))

By default it stores *package* from the time this test was defined (macroexpanded).

Source

classes.lisp.

Target Slot

runtime-package.

Generic Reader: status (object)
Generic Writer: (setf status) (object)
Package

eos.

Methods
Reader Method: status ((testable-object testable-object))
Writer Method: (setf status) ((testable-object testable-object))

A symbol specifying the current status
of this test. Either: T - this test (and all its dependencies, have passed. NIL - this test
failed (either it failed or its dependecies weren’t met. :circular this test has a circular dependency and was skipped. Or :depends-not-satisfied or :resolving

Source

classes.lisp.

Target Slot

status.

Generic Reader: test-case (object)
Package

eos.

Methods
Reader Method: test-case ((condition check-failure))
Source

check.lisp.

Target Slot

test-case.

Reader Method: test-case ((test-result test-result))

automatically generated reader method

Source

check.lisp.

Target Slot

test-case.

Generic Writer: (setf test-case) (object)
Package

eos.

Methods
Writer Method: (setf test-case) ((condition check-failure))
Source

check.lisp.

Target Slot

test-case.

Writer Method: (setf test-case) ((test-result test-result))

automatically generated writer method

Source

check.lisp.

Target Slot

test-case.

Generic Reader: test-expr (object)
Package

eos.

Methods
Reader Method: test-expr ((condition check-failure))
Source

check.lisp.

Target Slot

test-expr.

Reader Method: test-expr ((test-result test-result))

automatically generated reader method

Source

check.lisp.

Target Slot

test-expr.

Generic Writer: (setf test-expr) (object)
Package

eos.

Methods
Writer Method: (setf test-expr) ((condition check-failure))
Source

check.lisp.

Target Slot

test-expr.

Writer Method: (setf test-expr) ((test-result test-result))

automatically generated writer method

Source

check.lisp.

Target Slot

test-expr.

Generic Function: test-failure-p (object)
Package

eos.

Source

check.lisp.

Methods
Method: test-failure-p (o)
Method: test-failure-p ((o test-failure))
Generic Reader: test-lambda (object)
Generic Writer: (setf test-lambda) (object)
Package

eos.

Methods
Reader Method: test-lambda ((test-case test-case))
Writer Method: (setf test-lambda) ((test-case test-case))

The function to run.

Source

classes.lisp.

Target Slot

test-lambda.

Generic Function: test-passed-p (object)
Package

eos.

Source

check.lisp.

Methods
Method: test-passed-p (o)
Method: test-passed-p ((o test-passed))
Generic Function: test-skipped-p (object)
Package

eos.

Source

check.lisp.

Methods
Method: test-skipped-p (o)
Method: test-skipped-p ((o test-skipped))
Generic Reader: tests (object)
Generic Writer: (setf tests) (object)
Package

eos.

Methods
Reader Method: tests ((test-suite test-suite))
Writer Method: (setf tests) ((test-suite test-suite))

The hash table mapping names to test
objects in this suite. The values in this hash table can be either test-cases or other test-suites.

Source

classes.lisp.

Target Slot

tests.


6.2.5 Conditions

Condition: check-failure

Signaled when a check fails.

Package

eos.

Source

check.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: reason
Initform

(quote "no reason given")

Initargs

:reason

Readers

reason.

Writers

(setf reason).

Slot: test-case
Initargs

:test-case

Readers

test-case.

Writers

(setf test-case).

Slot: test-expr
Initargs

:test-expr

Readers

test-expr.

Writers

(setf test-expr).

Condition: circular-dependency

Condition signaled when a circular dependency between test-cases has been detected.

Package

eos.

Source

run.lisp.

Direct superclasses

error.

Direct slots
Slot: test-case
Initargs

:test-case


6.2.6 Classes

Class: detailed-text-explainer
Package

eos.

Source

classes.lisp.

Direct superclasses

text-explainer.

Direct methods

explain.

Class: explainer
Package

eos.

Source

classes.lisp.

Direct subclasses

text-explainer.

Class: simple-text-explainer
Package

eos.

Source

classes.lisp.

Direct superclasses

text-explainer.

Direct methods

explain.

Class: test-case

A test case is a single, named, collection of
checks.

A test case is the smallest organizational element which can be run individually. Every test case has a name, which is a symbol, a description and a test lambda. The test lambda is a regular funcall’able function which should use the various checking macros to collect results.

Every test case is part of a suite, when a suite is not explicitly specified (either via the :SUITE parameter to the TEST macro or the global variable *SUITE*) the test is inserted into the global suite named NIL.

Sometimes we want to run a certain test only if another test has passed. FiveAM allows us to specify the ways in which one test is dependent on another.

- AND Run this test only if all the named tests passed.

- OR Run this test if at least one of the named tests passed.

- NOT Run this test only if another test has failed.

FiveAM considers a test to have passed if all the checks executed were successful, otherwise we consider the test a failure.

When a test is not run due to it’s dependencies having failed a test-skipped result is added to the results.

Package

eos.

Source

classes.lisp.

Direct superclasses

testable-object.

Direct methods
Direct slots
Slot: test-lambda

The function to run.

Initargs

:test-lambda

Readers

test-lambda.

Writers

(setf test-lambda).

Slot: runtime-package

By default it stores *package* from the time this test was defined (macroexpanded).

Initargs

:runtime-package

Readers

runtime-package.

Writers

(setf runtime-package).

Class: test-failure

Class for unsuccessful checks.

Package

eos.

Source

check.lisp.

Direct superclasses

test-result.

Direct subclasses

unexpected-test-failure.

Direct methods

test-failure-p.

Class: test-passed

Class for successful checks.

Package

eos.

Source

check.lisp.

Direct superclasses

test-result.

Direct methods

test-passed-p.

Class: test-result

All checking macros will generate an object of type TEST-RESULT.

Package

eos.

Source

check.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: reason
Initform

"no reason given"

Initargs

:reason

Readers

reason.

Writers

(setf reason).

Slot: test-case
Initargs

:test-case

Readers

test-case.

Writers

(setf test-case).

Slot: test-expr
Initargs

:test-expr

Readers

test-expr.

Writers

(setf test-expr).

Class: test-skipped

A test which was not run. Usually this is due
to unsatisfied dependencies, but users can decide to skip test when appropiate.

Package

eos.

Source

check.lisp.

Direct superclasses

test-result.

Direct methods

test-skipped-p.

Class: test-suite

A test suite is a collection of tests or test suites.

Test suites serve to organize tests into groups so that the developer can chose to run some tests and not just one or all. Like tests test suites have a name and a description.

Test suites, like tests, can be part of other test suites, this allows the developer to create a hierarchy of tests where sub trees can be singularly run.

Running a test suite has the effect of running every test (or suite) in the suite.

Package

eos.

Source

classes.lisp.

Direct superclasses

testable-object.

Direct methods
Direct slots
Slot: tests

The hash table mapping names to test
objects in this suite. The values in this hash table can be either test-cases or other test-suites.

Initform

(make-hash-table :test (quote eql))

Readers

tests.

Writers

(setf tests).

Class: testable-object
Package

eos.

Source

classes.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: name

A symbol naming this test object.

Initargs

:name

Readers

name.

Writers

(setf name).

Slot: description

The textual description of this test object.

Initargs

:description

Readers

description.

Writers

(setf description).

Slot: depends-on

The list of AND, OR, NOT forms specifying when to run this test.

Initargs

:depends-on

Readers

depends-on.

Writers

(setf depends-on).

Slot: status

A symbol specifying the current status
of this test. Either: T - this test (and all its dependencies, have passed. NIL - this test
failed (either it failed or its dependecies weren’t met. :circular this test has a circular dependency and was skipped. Or :depends-not-satisfied or :resolving

Initform

:unknown

Initargs

:status

Readers

status.

Writers

(setf status).

Class: text-explainer
Package

eos.

Source

classes.lisp.

Direct superclasses

explainer.

Direct subclasses
Class: unexpected-test-failure

Represents the result of a test which neither
passed nor failed, but signaled an error we couldn’t deal with.

Note: This is very different than a SIGNALS check which instead creates a TEST-PASSED or TEST-FAILURE object.

Package

eos.

Source

check.lisp.

Direct superclasses

test-failure.

Direct methods
Direct slots
Slot: actual-condition
Initargs

:condition

Readers

actual-condition.

Writers

(setf actual-condition).


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   !   %   (  
A   B   C   D   E   F   G   I   L   M   N   P   R   S   T   V   W  
Index Entry  Section

!
!: Public ordinary functions
!!: Public ordinary functions
!!!: Public ordinary functions

%
%in-suite: Private macros
%run: Private generic functions
%run: Private generic functions
%run: Private generic functions
%run: Private generic functions
%run: Private generic functions

(
(setf actual-condition): Private generic functions
(setf actual-condition): Private generic functions
(setf depends-on): Private generic functions
(setf depends-on): Private generic functions
(setf description): Private generic functions
(setf description): Private generic functions
(setf get-test): Public ordinary functions
(setf name): Private generic functions
(setf name): Private generic functions
(setf reason): Private generic functions
(setf reason): Private generic functions
(setf reason): Private generic functions
(setf runtime-package): Private generic functions
(setf runtime-package): Private generic functions
(setf status): Private generic functions
(setf status): Private generic functions
(setf test-case): Private generic functions
(setf test-case): Private generic functions
(setf test-case): Private generic functions
(setf test-expr): Private generic functions
(setf test-expr): Private generic functions
(setf test-expr): Private generic functions
(setf test-lambda): Private generic functions
(setf test-lambda): Private generic functions
(setf tests): Private generic functions
(setf tests): Private generic functions

A
acond2: Private macros
actual-condition: Private generic functions
actual-condition: Private generic functions
add-result: Private ordinary functions
aif: Private macros

B
bind-run-state: Private macros
binding: Private ordinary functions

C
collect: Private macros

D
debug!: Public ordinary functions
def-suite: Public macros
def-suite*: Private macros
depends-on: Private generic functions
depends-on: Private generic functions
description: Private generic functions
description: Private generic functions

E
ensure-list: Private ordinary functions
explain: Public generic functions
explain: Public generic functions
explain: Public generic functions
explain!: Public ordinary functions

F
fail: Public macros
find-vars: Private ordinary functions
finishes: Public macros
fun: Private macros
Function, !: Public ordinary functions
Function, !!: Public ordinary functions
Function, !!!: Public ordinary functions
Function, (setf get-test): Public ordinary functions
Function, add-result: Private ordinary functions
Function, binding: Private ordinary functions
Function, debug!: Public ordinary functions
Function, ensure-list: Private ordinary functions
Function, explain!: Public ordinary functions
Function, find-vars: Private ordinary functions
Function, get-test: Public ordinary functions
Function, import-testing-symbols: Private ordinary functions
Function, list-match: Private ordinary functions
Function, make-suite: Public ordinary functions
Function, partition-results: Private ordinary functions
Function, rem-test: Public ordinary functions
Function, results-status: Public ordinary functions
Function, return-result-list: Private ordinary functions
Function, run: Public ordinary functions
Function, run!: Public ordinary functions
Function, test-names: Public ordinary functions
Function, varsymp: Private ordinary functions

G
Generic Function, %run: Private generic functions
Generic Function, (setf actual-condition): Private generic functions
Generic Function, (setf depends-on): Private generic functions
Generic Function, (setf description): Private generic functions
Generic Function, (setf name): Private generic functions
Generic Function, (setf reason): Private generic functions
Generic Function, (setf runtime-package): Private generic functions
Generic Function, (setf status): Private generic functions
Generic Function, (setf test-case): Private generic functions
Generic Function, (setf test-expr): Private generic functions
Generic Function, (setf test-lambda): Private generic functions
Generic Function, (setf tests): Private generic functions
Generic Function, actual-condition: Private generic functions
Generic Function, depends-on: Private generic functions
Generic Function, description: Private generic functions
Generic Function, explain: Public generic functions
Generic Function, name: Private generic functions
Generic Function, reason: Private generic functions
Generic Function, resolve-dependencies: Private generic functions
Generic Function, run-resolving-dependencies: Private generic functions
Generic Function, run-test-lambda: Private generic functions
Generic Function, runtime-package: Private generic functions
Generic Function, status: Private generic functions
Generic Function, test-case: Private generic functions
Generic Function, test-expr: Private generic functions
Generic Function, test-failure-p: Private generic functions
Generic Function, test-lambda: Private generic functions
Generic Function, test-passed-p: Private generic functions
Generic Function, test-skipped-p: Private generic functions
Generic Function, tests: Private generic functions
get-test: Public ordinary functions

I
import-testing-symbols: Private ordinary functions
in-suite: Public macros
in-suite*: Public macros
is: Public macros
is-false: Public macros
is-true: Public macros

L
list-match: Private ordinary functions
list-match-case: Private macros

M
Macro, %in-suite: Private macros
Macro, acond2: Private macros
Macro, aif: Private macros
Macro, bind-run-state: Private macros
Macro, collect: Private macros
Macro, def-suite: Public macros
Macro, def-suite*: Private macros
Macro, fail: Public macros
Macro, finishes: Public macros
Macro, fun: Private macros
Macro, in-suite: Public macros
Macro, in-suite*: Public macros
Macro, is: Public macros
Macro, is-false: Public macros
Macro, is-true: Public macros
Macro, list-match-case: Private macros
Macro, pass: Public macros
Macro, process-failure: Private macros
Macro, signals: Public macros
Macro, skip: Public macros
Macro, test: Public macros
Macro, with-*test-dribble*: Private macros
Macro, with-gensyms: Private macros
Macro, with-run-state: Private macros
make-suite: Public ordinary functions
Method, %run: Private generic functions
Method, %run: Private generic functions
Method, %run: Private generic functions
Method, %run: Private generic functions
Method, (setf actual-condition): Private generic functions
Method, (setf depends-on): Private generic functions
Method, (setf description): Private generic functions
Method, (setf name): Private generic functions
Method, (setf reason): Private generic functions
Method, (setf reason): Private generic functions
Method, (setf runtime-package): Private generic functions
Method, (setf status): Private generic functions
Method, (setf test-case): Private generic functions
Method, (setf test-case): Private generic functions
Method, (setf test-expr): Private generic functions
Method, (setf test-expr): Private generic functions
Method, (setf test-lambda): Private generic functions
Method, (setf tests): Private generic functions
Method, actual-condition: Private generic functions
Method, depends-on: Private generic functions
Method, description: Private generic functions
Method, explain: Public generic functions
Method, explain: Public generic functions
Method, name: Private generic functions
Method, print-object: Public standalone methods
Method, reason: Private generic functions
Method, reason: Private generic functions
Method, resolve-dependencies: Private generic functions
Method, resolve-dependencies: Private generic functions
Method, run-resolving-dependencies: Private generic functions
Method, run-test-lambda: Private generic functions
Method, runtime-package: Private generic functions
Method, status: Private generic functions
Method, test-case: Private generic functions
Method, test-case: Private generic functions
Method, test-expr: Private generic functions
Method, test-expr: Private generic functions
Method, test-failure-p: Private generic functions
Method, test-failure-p: Private generic functions
Method, test-lambda: Private generic functions
Method, test-passed-p: Private generic functions
Method, test-passed-p: Private generic functions
Method, test-skipped-p: Private generic functions
Method, test-skipped-p: Private generic functions
Method, tests: Private generic functions

N
name: Private generic functions
name: Private generic functions

P
partition-results: Private ordinary functions
pass: Public macros
print-object: Public standalone methods
process-failure: Private macros

R
reason: Private generic functions
reason: Private generic functions
reason: Private generic functions
rem-test: Public ordinary functions
resolve-dependencies: Private generic functions
resolve-dependencies: Private generic functions
resolve-dependencies: Private generic functions
results-status: Public ordinary functions
return-result-list: Private ordinary functions
run: Public ordinary functions
run!: Public ordinary functions
run-resolving-dependencies: Private generic functions
run-resolving-dependencies: Private generic functions
run-test-lambda: Private generic functions
run-test-lambda: Private generic functions
runtime-package: Private generic functions
runtime-package: Private generic functions

S
signals: Public macros
skip: Public macros
status: Private generic functions
status: Private generic functions

T
test: Public macros
test-case: Private generic functions
test-case: Private generic functions
test-case: Private generic functions
test-expr: Private generic functions
test-expr: Private generic functions
test-expr: Private generic functions
test-failure-p: Private generic functions
test-failure-p: Private generic functions
test-failure-p: Private generic functions
test-lambda: Private generic functions
test-lambda: Private generic functions
test-names: Public ordinary functions
test-passed-p: Private generic functions
test-passed-p: Private generic functions
test-passed-p: Private generic functions
test-skipped-p: Private generic functions
test-skipped-p: Private generic functions
test-skipped-p: Private generic functions
tests: Private generic functions
tests: Private generic functions

V
varsymp: Private ordinary functions

W
with-*test-dribble*: Private macros
with-gensyms: Private macros
with-run-state: Private macros


A.3 Variables

Jump to:   *  
A   D   N   R   S   T  
Index Entry  Section

*
*!!!*: Private special variables
*!!*: Private special variables
*!*: Private special variables
*debug-on-error*: Public special variables
*debug-on-failure*: Public special variables
*initial-!*: Private special variables
*run-queue*: Private special variables
*run-test-when-defined*: Public special variables
*suite*: Private special variables
*test*: Private special variables
*test-dribble*: Public special variables
*verbose-failures*: Public special variables

A
actual-condition: Private classes

D
depends-on: Private classes
description: Private classes

N
name: Private classes

R
reason: Private conditions
reason: Private classes
runtime-package: Private classes

S
Slot, actual-condition: Private classes
Slot, depends-on: Private classes
Slot, description: Private classes
Slot, name: Private classes
Slot, reason: Private conditions
Slot, reason: Private classes
Slot, runtime-package: Private classes
Slot, status: Private classes
Slot, test-case: Private conditions
Slot, test-case: Private conditions
Slot, test-case: Private classes
Slot, test-expr: Private conditions
Slot, test-expr: Private classes
Slot, test-lambda: Private classes
Slot, tests: Private classes
Special Variable, *!!!*: Private special variables
Special Variable, *!!*: Private special variables
Special Variable, *!*: Private special variables
Special Variable, *debug-on-error*: Public special variables
Special Variable, *debug-on-failure*: Public special variables
Special Variable, *initial-!*: Private special variables
Special Variable, *run-queue*: Private special variables
Special Variable, *run-test-when-defined*: Public special variables
Special Variable, *suite*: Private special variables
Special Variable, *test*: Private special variables
Special Variable, *test-dribble*: Public special variables
Special Variable, *verbose-failures*: Public special variables
status: Private classes

T
test-case: Private conditions
test-case: Private conditions
test-case: Private classes
test-expr: Private conditions
test-expr: Private classes
test-lambda: Private classes
tests: Private classes


A.4 Data types

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

C
check-failure: Private conditions
check.lisp: The eos/src/check․lisp file
circular-dependency: Private conditions
Class, detailed-text-explainer: Private classes
Class, explainer: Private classes
Class, simple-text-explainer: Private classes
Class, test-case: Private classes
Class, test-failure: Private classes
Class, test-passed: Private classes
Class, test-result: Private classes
Class, test-skipped: Private classes
Class, test-suite: Private classes
Class, testable-object: Private classes
Class, text-explainer: Private classes
Class, unexpected-test-failure: Private classes
classes.lisp: The eos/src/classes․lisp file
Condition, check-failure: Private conditions
Condition, circular-dependency: Private conditions

D
detailed-text-explainer: Private classes

E
eos: The eos system
eos: The eos package
eos.asd: The eos/eos․asd file
explain.lisp: The eos/src/explain․lisp file
explainer: Private classes

F
File, check.lisp: The eos/src/check․lisp file
File, classes.lisp: The eos/src/classes․lisp file
File, eos.asd: The eos/eos․asd file
File, explain.lisp: The eos/src/explain․lisp file
File, package.lisp: The eos/src/package․lisp file
File, run.lisp: The eos/src/run․lisp file
File, suite.lisp: The eos/src/suite․lisp file
File, test.lisp: The eos/src/test․lisp file
File, utils.lisp: The eos/src/utils․lisp file

M
Module, src: The eos/src module

P
Package, eos: The eos package
package.lisp: The eos/src/package․lisp file

R
run.lisp: The eos/src/run․lisp file

S
simple-text-explainer: Private classes
src: The eos/src module
suite.lisp: The eos/src/suite․lisp file
System, eos: The eos system

T
test-case: Private classes
test-failure: Private classes
test-passed: Private classes
test-result: Private classes
test-skipped: Private classes
test-suite: Private classes
test.lisp: The eos/src/test․lisp file
testable-object: Private classes
text-explainer: Private classes

U
unexpected-test-failure: Private classes
utils.lisp: The eos/src/utils․lisp file