Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the eos Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Dec 22 13:23:39 2020 GMT+0.
• Introduction | What eos is all about | |
• Systems | The systems documentation | |
• Modules | The modules documentation | |
• Files | The files documentation | |
• Packages | The packages documentation | |
• Definitions | The symbols documentation | |
• Indexes | Concepts, functions, variables and data types |
Eos was a unit testing library for Common Lisp.
It began as a fork of FiveAM; however, FiveAM development has continued, while that of Eos has not. Thus, Eos is now deprecated in favor of FiveAM.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
• The eos system |
Adlai Chandrasekhar
MIT
UNMAINTAINED fork of 5AM, a test framework
eos.asd (file)
src (module)
Modules are listed depth-first from the system components tree.
• The eos/src module |
eos (system)
src/
Files are sorted by type and then listed depth-first from the systems components trees.
• Lisp files |
Next: The eos/src/package․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
eos.asd
eos (system)
Next: The eos/src/utils․lisp file, Previous: The eos․asd file, Up: Lisp files [Contents][Index]
Next: The eos/src/classes․lisp file, Previous: The eos/src/package․lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
src (module)
src/utils.lisp
Next: The eos/src/check․lisp file, Previous: The eos/src/utils․lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
src (module)
src/classes.lisp
Next: The eos/src/test․lisp file, Previous: The eos/src/classes․lisp file, Up: Lisp files [Contents][Index]
utils.lisp (file)
src (module)
src/check.lisp
Next: The eos/src/explain․lisp file, Previous: The eos/src/check․lisp file, Up: Lisp files [Contents][Index]
classes.lisp (file)
src (module)
src/test.lisp
*test* (special variable)
Next: The eos/src/suite․lisp file, Previous: The eos/src/test․lisp file, Up: Lisp files [Contents][Index]
src (module)
src/explain.lisp
partition-results (function)
Next: The eos/src/run․lisp file, Previous: The eos/src/explain․lisp file, Up: Lisp files [Contents][Index]
src (module)
src/suite.lisp
Previous: The eos/src/suite․lisp file, Up: Lisp files [Contents][Index]
src (module)
src/run.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
• The eos package |
package.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
• Exported definitions | ||
• Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
• Exported special variables | ||
• Exported macros | ||
• Exported functions | ||
• Exported generic functions |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
T if we should drop into a debugger on error, NIL otherwise.
T if we should drop into a debugger on a failing check, NIL otherwise.
When non-NIL tests are run as soon as they are defined.
check.lisp (file)
T if we should print the expression failing, NIL otherwise.
explain.lisp (file)
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
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.
suite.lisp (file)
Simply generate a FAIL.
check.lisp (file)
Generates a pass if BODY executes to normal completion. In other words if body does signal, return-from or throw this test fails.
check.lisp (file)
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*
suite.lisp (file)
Just like in-suite, but silently creates missing suites.
suite.lisp (file)
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.
check.lisp (file)
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
check.lisp (file)
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.
check.lisp (file)
Simply generate a PASS.
check.lisp (file)
Generates a pass if BODY signals a condition of type CONDITION. BODY is evaluated in a block named NIL, CONDITION is not evaluated.
check.lisp (file)
Generates a TEST-SKIPPED result.
check.lisp (file)
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.
Next: Exported generic functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
Rerun the most recently run test and explain the results.
Rerun the second most recently run test and explain the results.
Rerun the third most recently run test and explain the results.
Calls (run! test-spec) but enters the debugger if any kind of error happens.
Explain the results of RESULT-LIST using a detailed-text-explainer with output going to *test-dribble*
Create a new test suite object.
Overides any existing suite named NAME.
suite.lisp (file)
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.
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.
Equivalent to (explain (run TEST-SPEC)).
Previous: Exported functions, Up: Exported definitions [Contents][Index]
explain.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
• Internal special variables | ||
• Internal macros | ||
• Internal functions | ||
• Internal generic functions | ||
• Internal conditions | ||
• Internal classes |
Next: Internal macros, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
The current test suite object
suite.lisp (file)
Table containing all test and test suite objects.
Next: Internal functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
suite.lisp (file)
utils.lisp (file)
utils.lisp (file)
check.lisp (file)
utils.lisp (file)
suite.lisp (file)
utils.lisp (file)
utils.lisp (file)
check.lisp (file)
check.lisp (file)
This is a simple WITH-GENSYMS, similar to the one presented in PCL.
utils.lisp (file)
check.lisp (file)
Next: Internal generic functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
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.
check.lisp (file)
utils.lisp (file)
utils.lisp (file)
utils.lisp (file)
utils.lisp (file)
explain.lisp (file)
Run the test function TEST-LAMBDA and return a list of all test results generated, does not modify the special environment variable RESULT-LIST.
utils.lisp (file)
Next: Internal conditions, Previous: Internal functions, Up: Internal definitions [Contents][Index]
Internal method for running a test. Does not update
the status of the tests nor the special vairables !, !!, or !!!
automatically generated reader method
check.lisp (file)
automatically generated writer method
check.lisp (file)
The list of AND, OR, NOT forms specifying when to run this test.
classes.lisp (file)
The textual description of this test object.
classes.lisp (file)
A symbol naming this test object.
classes.lisp (file)
check.lisp (file)
automatically generated reader method
check.lisp (file)
automatically generated writer method
check.lisp (file)
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.
By default it stores *package* from the time this test was defined (macroexpanded).
classes.lisp (file)
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
classes.lisp (file)
check.lisp (file)
automatically generated reader method
check.lisp (file)
automatically generated writer method
check.lisp (file)
check.lisp (file)
automatically generated reader method
check.lisp (file)
automatically generated writer method
check.lisp (file)
check.lisp (file)
The function to run.
classes.lisp (file)
check.lisp (file)
check.lisp (file)
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.
classes.lisp (file)
Next: Internal classes, Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
Signaled when a check fails.
check.lisp (file)
error (condition)
:reason
(quote "no reason given")
reason (generic function)
(setf reason) (generic function)
:test-case
test-case (generic function)
(setf test-case) (generic function)
:test-expr
test-expr (generic function)
(setf test-expr) (generic function)
Condition signaled when a circular dependency between test-cases has been detected.
Previous: Internal conditions, Up: Internal definitions [Contents][Index]
classes.lisp (file)
text-explainer (class)
explain (method)
classes.lisp (file)
standard-object (class)
text-explainer (class)
classes.lisp (file)
text-explainer (class)
explain (method)
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.
classes.lisp (file)
testable-object (class)
The function to run.
:test-lambda
test-lambda (generic function)
(setf test-lambda) (generic function)
By default it stores *package* from the time this test was defined (macroexpanded).
:runtime-package
runtime-package (generic function)
(setf runtime-package) (generic function)
Class for unsuccessful checks.
check.lisp (file)
test-result (class)
unexpected-test-failure (class)
test-failure-p (method)
Class for successful checks.
check.lisp (file)
test-result (class)
test-passed-p (method)
All checking macros will generate an object of type TEST-RESULT.
check.lisp (file)
standard-object (class)
:reason
"no reason given"
reason (generic function)
(setf reason) (generic function)
:test-case
test-case (generic function)
(setf test-case) (generic function)
:test-expr
test-expr (generic function)
(setf test-expr) (generic function)
A test which was not run. Usually this is due
to unsatisfied dependencies, but users can decide to skip test
when appropiate.
check.lisp (file)
test-result (class)
test-skipped-p (method)
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.
classes.lisp (file)
testable-object (class)
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.
(make-hash-table :test (quote eql))
tests (generic function)
(setf tests) (generic function)
classes.lisp (file)
standard-object (class)
A symbol naming this test object.
:name
name (generic function)
(setf name) (generic function)
The textual description of this test object.
:description
description (generic function)
(setf description) (generic function)
The list of AND, OR, NOT forms specifying when to run this test.
:depends-on
depends-on (generic function)
(setf depends-on) (generic function)
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
:status
:unknown
status (generic function)
(setf status) (generic function)
classes.lisp (file)
explainer (class)
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.
check.lisp (file)
test-failure (class)
:condition
actual-condition (generic function)
(setf actual-condition) (generic function)
Previous: Definitions, Up: Top [Contents][Index]
• Concept index | ||
• Function index | ||
• Variable index | ||
• Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
Jump to: | E F L M |
---|
Jump to: | E F L M |
---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
Jump to: | !
%
(
A B C D E F G I L M N P R S T V W |
---|
Jump to: | !
%
(
A B C D E F G I L M N P R S T V W |
---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
Jump to: | *
A D N R S T |
---|
Jump to: | *
A D N R S T |
---|
Previous: Variable index, Up: Indexes [Contents][Index]
Jump to: | C D E P S T U |
---|
Jump to: | C D E P S T U |
---|